Are Online Password Generators Safe?
The question is legitimate: you are using a website to generate a secret that protects your accounts. Could the website log that secret, transmit it to a server, or store it somewhere you cannot see? The answer depends entirely on how the generator is built — and this guide explains how to tell the difference.
Client-Side vs Server-Side Generation
Password generators fall into two architectural categories:
Client-side generators run entirely in your browser. The server delivers the HTML, CSS, and JavaScript once; after that, all password generation happens locally using your device's CPU and the browser's built-in cryptographic API (window.crypto.getRandomValues()). The generated password never leaves your device. The server cannot see it because the server is not involved in generating it.
Server-side generators send a request to a remote server that generates the password and returns it in the response. This means the password travels over the network, exists on the server at the moment of creation, and could — in theory — be logged, intercepted, or stored. Even with HTTPS, the server operator has access to the plaintext password at the point of generation.
The Strong Password Generator is client-side only. No passwords are sent to any server, ever. Generation uses crypto.getRandomValues(), the same CSPRNG that your operating system uses internally.
How to Verify a Generator Is Client-Side
You should not have to take any generator's word for this. Here are four concrete ways to verify it yourself:
1. Check the Network Tab
Open your browser's developer tools (F12 or right-click → Inspect), go to the Network tab, and generate a password. A client-side generator will show no new network requests at the moment of generation — only requests that load the page itself. If you see a POST or GET request firing when you click Generate, the generator is contacting a server. On this site you may also see requests to /stats/ — that is the analytics script described below; open one and you will find page and click data, never a password.
2. View the Source Code
Right-click the page and choose View Page Source. Look for references to crypto.getRandomValues or a JavaScript implementation that operates on local arrays. Absence of any API endpoint URL in the generation logic is a good sign. Presence of a fetch() or XMLHttpRequest() call that runs when you generate a password is a red flag.
3. Check for Published Source Code
Some generators publish their source code on GitHub or a similar platform, where you can read the generation logic, verify which random source it uses, and check for any network calls. That is a useful extra, but not a guarantee on its own: the code a site serves can differ from the code in its repository. This site's code is not open source, which is exactly why checks 1, 2 and 4 matter — they test the code your browser actually runs, on any generator, open or closed.
4. Test It Offline
Load the page, then turn off your network connection (disable Wi-Fi or disconnect Ethernet) and try generating a password. A fully client-side generator will continue to work without internet access. A server-side generator will fail.
What About Analytics and Trackers?
Even a client-side generator might run third-party analytics scripts. These scripts generally track page views and user interactions, not password values — but they add network traffic and represent an additional surface area. A generator that loads no third-party scripts at all provides the cleanest privacy boundary.
You can inspect loaded scripts in the Network tab by filtering to JS files. Requests to domains like google-analytics.com, clarity.ms, or hotjar.com indicate third-party analytics. Whether these are acceptable depends on your threat model — but note that local generation does not protect a password from them: any script running in the same page can technically read what the page displays. Fewer scripts, and none from third parties, is the stronger position.
In the interest of the same transparency we ask you to apply elsewhere: this site runs one analytics service — a self-hosted, cookieless Umami instance whose two script files are served from this same domain, so no request leaves it. It counts page views and, for a sample of visits, records click and scroll heatmaps and text-masked session replays. Every element that shows or accepts a password is excluded from those recordings in the page code, so it never sees a generated password; you can verify that with the exact Network-tab check described above.
Our Privacy Promise
This site generates all passwords entirely in your browser. No password, no user ID, and no generated value is ever transmitted to our servers or any third party. The code is not open source, but every one of these claims can be checked from your own browser with the tests above.
For full details on what data this site does and does not collect, see the privacy policy.
Common Misconceptions
"HTTPS means my password is safe in transit." HTTPS protects the connection between your browser and the server, but it does not prevent the server from seeing a password it generated. If the server created the password, the server already had it before encryption began.
"Using a well-known site guarantees safety." Reputation is not architecture. A site with millions of users can still be server-side. Verify the technical implementation, not the brand.
"I should generate my own password mentally to be safe." Human- generated passwords are consistently less random than generator-produced ones. The safety of a client-side generator, once verified, is higher than self-invented passwords — because it provides genuine randomness without introducing exploitable patterns.
Summary
A well-built online password generator is safe. The key property to verify is whether generation happens client-side using crypto.getRandomValues(). You can confirm this via the Network tab, page source inspection and offline testing — plus, where a generator publishes it, its source code. The Strong Password Generator passes the network, page-source and offline checks.