This guide covers:
- background on NET SEND and why it matters;
- how NET SEND works and its modern equivalents;
- creating bulk messaging using built-in commands and simple scripts;
- example PowerShell and batch scripts for multi-recipient delivery;
- considerations for reliability, security, and compatibility;
- troubleshooting and alternatives (including Windows Toast/Win32 notifications, msg.exe, and third‑party tools).
Background: NET SEND and its place in Windows messaging
NET SEND was part of the Messenger service in older Windows (NT/2000/XP-era). It delivered short pop-up messages across a LAN using the Messenger service and the SMB/RPC transport. Because the Messenger service was often abused for spam and worm propagation, Microsoft disabled or removed it in later Windows versions. On modern Windows, the direct NET SEND command may not exist; instead, administrators use msg.exe, PowerShell, WSH scripts, or third-party utilities.
Key takeaway: NET SEND is deprecated; use msg.exe or PowerShell alternatives on modern systems.
How NET SEND worked (short technical overview)
The classic NET SEND command sends a message to:
- a username;
- a computer name;
- a session or workstation name; or
- a broadcast to the entire domain or workgroup.
Syntax (legacy):
NET SEND <name> <message>
It relied on the Messenger service (server-side) and SMB-based messaging. Because that service is disabled on modern Windows, NET SEND often fails unless legacy services/tools are reinstalled and enabled — which is not recommended for security reasons.
Modern equivalents and why to use them
- msg.exe — built into many modern Windows editions; sends a message to a user session on local or remote machines (Terminal Services / Remote Desktop aware).
- PowerShell Remoting (Invoke-Command) — run a script block remotely to display notifications or write files.
- Scheduled Tasks or PSExec — remotely execute a script that shows a UI notification.
- Toast notifications (Windows ⁄11) — modern user-visible notifications for desktop apps or scheduled scripts.
- Third-party tools — offer bulk delivery with retries, authentication, and richer UI.
Recommendation: For immediate, administrative pop-ups on a LAN, use msg.exe or PowerShell-based notifications instead of NET SEND.
Basic multi-recipient approaches
There are two common strategies to send the same message to many recipients:
- Serial loop: iterate through a list of targets and send messages one by one. Simple, but slower.
- Parallel delivery: spawn concurrent processes/threads to deliver messages simultaneously. Faster but more complex and system-load-sensitive.
Which to choose depends on scale (tens vs thousands), network environment, and whether ordering or confirmation is required.
Example 1 — Batch script using msg.exe (serial)
Create a text file (computers.txt) with one target per line (computer names or usernames). Use this batch file:
@echo off setlocal enabledelayedexpansion set MESSAGE=This is a scheduled network alert. Please save work and reboot. for /f "usebackq tokens=*" %%A in ("computers.txt") do ( echo Sending to %%A msg /server:%%A * "%MESSAGE%" timeout /t 1 >nul ) endlocal
Notes:
msg /server:Name * "message" attempts to deliver to all sessions on that server.- Some systems require admin privileges or matching user sessions; UAC and firewall can block delivery.
Example 2 — PowerShell (parallel, with throttling)
This PowerShell script uses Start-Job to parallelize sends with a controlled max concurrency:
$targets = Get-Content -Path ".mputers.txt" $message = "System maintenance in 10 minutes. Save your work." $maxConcurrent = 20 $jobs = @() foreach ($t in $targets) { while (($jobs | Where-Object { $_.State -eq 'Running' }).Count -ge $maxConcurrent) { Start-Sleep -Seconds 1 $jobs = $jobs | Where-Object { $_.State -ne 'Completed' -and $_.State -ne 'Failed' -and $_.State -ne 'Stopped' } } $jobs += Start-Job -ScriptBlock { param($target, $message) try { # Use msg.exe remotely; suppress errors & msg /server:$target * $message 2>$null } catch { # fallback: try PowerShell remoting to create a balloon/toast try { Invoke-Command -ComputerName $target -ScriptBlock { param($m) Add-Type -AssemblyName System.Windows.Forms [System.Windows.Forms.MessageBox]::Show($m, "Network Message") } -ArgumentList $message -ErrorAction SilentlyContinue } catch { # log or ignore } } } -ArgumentList $t, $message } # Wait for all jobs Get-Job | Wait-Job Get-Job | Receive-Job
Important: PowerShell remoting must be enabled on targets (Enable-PSRemoting), and you need appropriate credentials.
Example 3 — Using PSExec for remote execution
PsExec (Sysinternals) can run a command remotely that displays a native UI. Example:
psexec \TARGET -i -d cmd /c "msg * System maintenance in 10 minutes. Save your work."
-i runs interactively in the console session (session 1); may be needed to show UI to logged-in user.-d doesn’t wait for process to terminate.
Security: PsExec requires admin rights on the remote machine and may be blocked by security tools.
Creating robust bulk messaging (best practices)
- Authenticate: run scripts with an account that has administrative rights or proper permissions.
- Test: try on a small subset before full rollout.
- Respect sessions: msg.exe targets user sessions; if no user logged in, the message won’t appear.
- Logging & retries: log successes and failures and retry transient failures.
- Throttle: limit concurrent sends to avoid saturating network or domain controllers.
- Use secure channels: prefer PowerShell Remoting over older, insecure protocols.
- Consider user experience: use clear subject, brief message, and instructions if action is required.
Troubleshooting common issues
- “Error opening session” or “No such interface supported”: Messenger service removed or not supported — use msg.exe or PowerShell remoting.
- Access denied: insufficient permissions; run elevated or provide credentials.
- No popup shown: user not logged in locally/remote session mismatch; interactive session not available.
- Firewall blocks: ensure RPC/SMB or WinRM ports open as needed.
- Domain vs Workgroup: domain policies and permissions differ; test accordingly.
Alternatives to NET SEND for modern Windows
- msg.exe — easiest direct replacement for NET SEND when sessions exist.
- Toast notifications via PowerShell/WinRT — modern, user-friendly notifications (Windows ⁄11).
- Centralized alerting systems (Slack, Teams, email + SMS) — better for broad, persistent alerts.
- Endpoint management tools (SCCM, Intune) — can push notifications and scripts at scale.
- ChatOps and Webhooks — integrate with modern ops workflows for confirmations and logging.
Comparison table:
| Method |
Works on modern Windows? |
Requires admin/remote config |
Visible to logged-in user |
| NET SEND (legacy) |
No (deprecated) |
Messenger service + legacy config |
Yes (if service present) |
| msg.exe |
Yes (often) |
Usually needs admin or same domain |
Yes (per session) |
| PowerShell Remoting |
Yes |
Enable-PSRemoting, creds |
Yes (if script shows UI) |
| PsExec |
Yes |
Admin on remote host |
Yes (with -i) |
| Toast notifications |
Yes |
App/Script permissions |
Yes, modern look |
| Third-party tools |
Yes |
Varies |
Yes, often robust |
Security and policy considerations
- Avoid re-enabling deprecated Messenger services — they introduce security risk.
- Ensure messaging scripts and tools run under audited, least-privilege accounts.
- Consider privacy and company policies before broadcasting messages widely.
- Use secure communications (WinRM over HTTPS) when possible.
Sample checklist for a bulk-notification run
- Prepare recipient list and test targets (5–10 machines).
- Choose method (msg.exe, PowerShell Remoting, PsExec).
- Validate permissions and remote access.
- Schedule during low-impact time and notify admins.
- Run with throttling and monitor logs.
- Confirm delivery with a subset of users.
- Document outcomes and follow up on failures.
Final notes
While “NET SEND” has nostalgic value, modern Windows environments should use supported tools like msg.exe, PowerShell Remoting, or endpoint management platforms for bulk messaging. Choose the approach that balances visibility, security, and scale for your environment.
If you want, I can: produce ready-to-run scripts tailored to your environment (domain vs workgroup), generate a scheduled task example, or show how to create modern toast notifications via PowerShell. Which would you like?