Client-Side Tools: Benefits, Limits, and Exceptions
Most tools on BoltQuickTools do their work in your browser instead of on a server. This post explains what that means in concrete terms, which tools are exceptions, why the approach is useful, and what it costs.
What "client-side" means here
The phrase gets used loosely, so here is what actually happens:
- Static page delivery. nginx behind Cloudflare serves a plain HTML file for each tool. There is no application server that receives tool input.
- In-browser computation. Tools use standard Web APIs (Canvas, Web Crypto, FileReader, CompressionStream, TextEncoder) and JavaScript that ships with the page.
- Local storage. Some tools keep preferences or recent items in localStorage, which stays in that browser profile.
The exceptions
Not every tool can avoid the network. These do not stay entirely local:
- API Tester sends the request you build, including its headers and body, directly from your browser to the URL you enter. Sending a request is the purpose of the tool.
- DNS Lookup sends the domain you type to Cloudflare's DNS-over-HTTPS service.
- OCR downloads the Tesseract.js library and language data from CDNs. Recognition runs locally, so the image stays in your browser.
- Bcrypt Generator loads the bcryptjs library from cdnjs. Hashing runs locally, so your password is not part of that request.
Separately, every page loads scripts that have nothing to do with the tools: Google AdSense for ads (after consent, as described in the privacy policy), Cloudflare Web Analytics for page view counts, and Google Translate for the language switcher. These run in the same page as the tools, so you are trusting them along with the site's own code.
You can check any of this in a few seconds. Open DevTools, switch to the Network tab, use a tool, and read the list of requests. If input is being sent somewhere, the request will be there.
Effect on speed
A server-based tool has to pay for a network round trip before it can return anything, and that cost has a physical floor. Light in optical fiber covers about 200 km per millisecond, so a server 6,000 km away cannot answer in less than about 60 ms, before routing, TLS, and queueing are added. For small inputs, the work itself is usually much cheaper than that. You can measure it in your browser console:
const input = JSON.stringify(
Array.from({ length: 2000 }, (_, i) => ({ id: i, name: 'user' + i }))
);
console.time('format');
JSON.stringify(JSON.parse(input), null, 2);
console.timeEnd('format');
This advantage shrinks as inputs grow and as the visitor's device gets slower. A server with fast hardware will win some large jobs even after the network cost.
Effect on privacy and security
When a tool does not send your input anywhere, some risks go away:
- No stored input to leak. A common failure for server-side tools is logging inputs for debugging and then exposing the logs. A server cannot log what it never received. It does still see the request for the page itself, including your IP address and User-Agent.
- No operator access. If you upload a file to a service, people at that company could read it. With local processing, that question does not come up.
- No legal disclosure of input. A site cannot be compelled to hand over tool input it never had.
This does not make a page risk-free. A client-side tool is only as trustworthy as the JavaScript it runs, and that code could change tomorrow.
The trade-offs
Heavy computation is harder
Browsers limit how much memory a tab can use, and long-running code on the main thread freezes the page. Large images, video, and neural networks all run into this. The image upscaler on this site is an example of the compromise: it uses classic interpolation (Bilinear, Bicubic, Lanczos, Nearest Neighbor) rather than a machine learning model, so it enlarges images without inventing detail the way server-side AI upscalers do.
No cross-device sync
Data in localStorage exists only in one browser profile. Sharing history between a laptop and a phone would take a backend and accounts, and the site has neither.
Trust is harder to communicate
Someone who pastes a private key into a tool has to trust that the page is not sending it anywhere. DevTools can confirm that, but most people will not check. For a secret you cannot afford to expose, a command-line tool on your own machine is still the safest choice.
Where local processing matters most
For a JSON formatter handling public data, running locally is mostly a convenience. For these tools it changes the risk:
- Basic auth header generator: the input is a username and password.
- Hash generators: inputs are often sensitive. Note that fast hashes such as SHA-256 are the wrong choice for storing passwords.
- JWT decoder: tokens often contain user identifiers and can still be valid when pasted.
- EXIF viewer and Image to Base64: inputs are often personal photos.
Before you paste anything sensitive into any online tool, on this site or elsewhere, open the Network tab and watch what it sends. That test is more reliable than any claim on the page, including this one.