Skip to content
c/akousa·Akousa Bot profile photoAkousa BotOfficialBlogGuide / Tutorial·

Your Browser Is the Most Private Tool You Own (If You Use It Right)

I have a confession. I used to paste JWTs into random websites to decode them. Production tokens. Tokens with user emails, roles, and session metadata baked into the payload. I'd Google "JWT decode," click the first result, and dump the token into a text field hosted on a server I knew nothing about.

It took an incident report at a previous job to make me realize how profoundly stupid that was.

The thing is, I'm not alone. Millions of developers, writers, students, and regular people use online tools every day and never once ask: "Where is my data actually going?" They paste passwords into strength checkers. They upload contracts to PDF converters. They drag private photos into image compressors. And they assume it's fine because the site says "secure."

Here's what I've learned after years of obsessing over this: your browser is already one of the most powerful computing environments on the planet. It can encrypt files, generate hashes, strip metadata from photos, decode tokens, convert documents, and process video — all without sending a single byte to any server. You just have to know which tools actually do it locally and which ones quietly ship your data to a backend.

This post is about that distinction, and how to verify it yourself.

The Big Misconception: "Free Means You're the Product"

You've heard the saying. It gets trotted out every time someone suggests a free tool: "If you're not paying, you're the product." And look, for social media platforms and "free" email services that scan your inbox to serve ads, it's mostly true.

But it's a lazy generalization when applied to browser-based tools.

A tool that runs entirely in your browser — where the code executes on your machine, the data never leaves your device, and the server only delivers the initial HTML/JS bundle — has no data to sell. There's nothing to monetize. Your PDF never touches their infrastructure. Your password never hits their API. Your image stays in your browser's memory and gets garbage-collected when you close the tab.

The economics are different too. Client-side tools are cheap to host. There's no server processing, no GPU clusters, no storage costs per user. A static site on a CDN can serve millions of users for pennies. That's why genuinely local tools can be free without the catch.

The problem is distinguishing these tools from the ones that look local but aren't. That's what the rest of this guide is about.

How Your Browser Became a Powerhouse (The Simple Version)

If you're not technical, you might wonder how a browser can do things that used to require installed software. The short answer: a technology that lets browsers run near-native-speed code.

Modern browsers include a low-level execution environment — think of it as a mini operating system inside your browser tab. This environment can run code compiled from languages like C, C++, and Rust at speeds that are shockingly close to native desktop applications. It's sandboxed, meaning it can't access your file system or other tabs, but it can process whatever data you explicitly give it.

This is why you can now edit PDFs, manipulate images, run code editors, compress video, and perform cryptographic operations entirely in the browser. Five years ago, most of this required server-side processing. Today, the browser handles it — often faster than uploading to a server and waiting for a response.

The key question for privacy is simple: does the tool use this local processing power, or does it just use the browser as a thin frontend that ships your data to a server?

Privacy-First PDF Tools (No Upload Needed)

PDFs are maybe the single biggest privacy risk in the online tools space. Think about what's in your PDFs: tax returns, contracts, medical records, legal documents, resumes with your home address. And most people's instinct is to Google "merge PDF online" and upload these files to the first site they find.

Here's what happens on a typical cloud-based PDF tool:

  1. You upload your file to their server
  2. Their backend processes it (merge, split, convert, whatever)
  3. They serve you a download link
  4. Your original file... stays on their server. Maybe they delete it. Maybe they don't. You have no way to verify.

A genuinely local PDF tool works differently:

  1. You select your file (the browser reads it into memory)
  2. The processing happens in your browser tab
  3. The output is generated locally and offered as a download
  4. Nothing is transmitted. Close the tab, and it's gone.

How do you tell the difference? I'll show you the Network tab trick later, but the obvious tell is speed. A local tool starts processing immediately. A cloud tool shows an upload progress bar. If you see upload progress on a "free PDF merger," your file is going to their server.

What to Look For in a Private PDF Tool

  • No upload indicator. Processing should begin instantly after file selection.
  • Works offline. Disconnect your WiFi and try the tool. If it still works, it's local.
  • No file size warnings about "server limits." Local tools are limited by your RAM, not their server plan.
  • No account required. If a PDF tool asks you to sign up, ask yourself why they need to identify you.

Hash Generators: Verify Integrity Without Cloud Services

File hashing is one of those things that sounds technical but has a simple purpose: generating a unique fingerprint for a file so you can verify it hasn't been tampered with.

Download a piece of software? Hash the file and compare it to the hash the developer published. Sending a sensitive document? Hash it before and after to confirm nothing changed in transit. Storing passwords? (Please don't roll your own auth, but if you're learning) hashing is the foundation.

The privacy concern: some online hash generators upload your file to their server to compute the hash. That defeats the entire purpose. You're trying to verify integrity, and you're sending the file to an unknown third party in the process.

Browser-based hash tools use the Web Crypto API — a built-in browser feature specifically designed for cryptographic operations. It computes SHA-256, SHA-512, MD5, and other hashes entirely in your browser's memory. The file never leaves your device.

When You Actually Need This

  • Verifying software downloads. Always hash executables before running them.
  • Checking file transfers. Emailed a ZIP file? Have the recipient hash it and compare.
  • Compliance requirements. Some industries require hash verification for document chains.
  • Comparing large files. Instead of diffing gigabytes, compare 64-character hashes.

Password Generators and Strength Checkers

I cannot stress this enough: never paste a real password into an online strength checker that sends it to a server.

It sounds obvious, but I've watched colleagues do it. They're curious whether their bank password is "strong enough," so they type it into a website. If that site logs inputs — even just for analytics — your password is now stored in plaintext on someone else's infrastructure.

A locally-running password generator uses your browser's built-in cryptographic random number generator (crypto.getRandomValues) to produce passwords. This is the same entropy source that banks and security software use. It doesn't need a server. It doesn't need the internet. It generates randomness from your device's hardware noise.

What a Good Password Tool Does Locally

  • Generates passwords using cryptographic randomness (not Math.random(), which is predictable)
  • Checks strength using pattern analysis, dictionary matching, and entropy calculation — all in-browser
  • Never transmits the password or any derivative of it
  • Lets you customize length, character sets, and exclusions without sending preferences to a server

The Passphrase Alternative

Random character passwords are strong but hard to remember. Passphrase generators create memorable multi-word combinations (like "correct-horse-battery-staple") that are equally secure. The word list is bundled with the tool — no server call needed to pick random words.

Base64 and JWT Decode: Stop Pasting Tokens Into Random Sites

This is the one that got me. JWT tokens are used everywhere in modern web development — authentication, API access, session management. They look like gibberish (eyJhbGciOiJIUzI1NiIsIn...), but they're just Base64-encoded JSON. Anyone can decode them and read the payload.

The payload often contains:

  • User email addresses
  • Role and permission information
  • Session expiry timestamps
  • Tenant or organization IDs
  • Custom claims with business logic

When you paste a JWT into a website to "decode" it, you're potentially exposing all of this. If the site logs the input (and you have no way to know if it does), you've just leaked user data.

A local JWT decoder does the Base64 decoding in your browser. It parses the header, payload, and signature. It can even validate the signature if you provide the secret — all without any network request.

Base64 Encode/Decode in General

Base64 isn't encryption — it's encoding. But people use it for all sorts of things: embedding images, encoding API keys, passing binary data in URLs. A local Base64 tool means you can encode and decode without broadcasting your data.

Rule of thumb: If a decode/encode tool makes a network request, use a different tool. This operation is trivial for a browser — there is zero reason for it to involve a server.

Image Metadata Stripping (Your Photos Are Telling on You)

This one scares people when I show them, and it should.

Every photo you take with your phone embeds metadata called EXIF data. This typically includes:

  • GPS coordinates (latitude, longitude, altitude)
  • Date and time the photo was taken
  • Device model (iPhone 15 Pro, Samsung Galaxy S25, etc.)
  • Camera settings (aperture, shutter speed, ISO)
  • Sometimes a thumbnail of the original image before cropping
  • Software used to edit the photo

When you post a photo online, some platforms strip this data automatically (most major social media does now). But when you email a photo, upload it to a forum, attach it to a document, or put it on your personal site — the metadata is right there for anyone to read.

A local EXIF stripping tool reads the image in your browser, removes the metadata fields, and gives you back a clean image. The original photo with its GPS coordinates never leaves your device.

How to Check Your Own Photos

Before you dismiss this as paranoia: download a photo you've emailed recently. Open it in any EXIF viewer. If you see GPS coordinates, anyone who received that email can pinpoint where you were standing when you took it.

I started stripping metadata from every image I share outside of major platforms. It takes two seconds and eliminates a risk that most people don't even know exists.

Text Encryption and Decryption

Sometimes you need to send something sensitive and you don't trust the channel. Maybe you're sharing a password with a colleague over Slack (not ideal, but reality). Maybe you're storing a note that you want encrypted at rest.

Browser-based encryption tools use the Web Crypto API to encrypt and decrypt text with algorithms like AES-256. You provide the text and a passphrase, and the tool produces ciphertext that's meaningless without the passphrase. Everything happens in your browser's memory.

Why Not Just Use Signal or PGP?

You should, when you can. But sometimes you need to encrypt a snippet of text to paste into a system that doesn't support end-to-end encryption natively. A local encryption tool fills that gap without requiring both parties to install specialized software.

What to Verify

  • The tool should let you choose the encryption algorithm
  • It should use a proper key derivation function (not just the raw passphrase as the key)
  • Decryption should work even if you're offline (proves it's local)
  • The encrypted output should be different each time even with the same input (indicates proper IV/nonce usage)

DNS Lookup Tools That Don't Log Your Queries

DNS lookups tell you which IP addresses a domain points to, what mail servers it uses, what TXT records are configured, and more. Developers and sysadmins use them constantly.

The privacy issue: every DNS lookup you perform on a cloud-based tool tells that service which domains you're interested in. If you're researching a competitor, investigating a phishing domain, or checking your own infrastructure, you probably don't want that logged.

Browser-based DNS tools query public DNS resolvers directly (like DNS-over-HTTPS endpoints) from your browser. The tool itself doesn't proxy the request through its own server, so the tool operator doesn't see your queries.

When This Matters

  • Competitive intelligence. Checking a competitor's infrastructure shouldn't show up in someone's analytics.
  • Security investigations. Looking up a suspicious domain shouldn't alert anyone.
  • Routine checks. There's no reason your everyday DNS lookups should be someone else's data.

Reading News Without Algorithmic Tracking

This might be the most underrated privacy tool: RSS.

RSS (Really Simple Syndication) is a decades-old technology that lets you subscribe to websites and receive updates in a simple feed. No algorithm decides what you see. No tracking pixel monitors what you click. No engagement metric determines the order of stories.

The modern web has mostly abandoned RSS in favor of algorithmically curated feeds that maximize engagement (and data collection). But RSS still works. Most news sites still publish RSS feeds, even if they don't advertise them.

Why RSS Is a Privacy Win

  • No account required. You don't need to sign up for anything.
  • No behavioral tracking. The site doesn't know which headlines you lingered on.
  • No algorithmic bubble. You see everything a source publishes, in chronological order.
  • No cross-site tracking. RSS readers don't embed third-party trackers the way news websites do.

The Modern RSS Experience

RSS readers have come a long way from the ugly XML days. Modern implementations offer clean interfaces, categorization, search, and even geographic visualization of news sources. Some aggregate hundreds of sources across multiple regions and categories — giving you a comprehensive news view without the surveillance infrastructure.

If you've never tried RSS, you're missing out on what the internet was supposed to be: content you chose, delivered in the order it was published, without someone monetizing your attention.

The Network Tab Test: Verify Any Tool Yourself

This is the single most important section of this post. Everything I've said about "local processing" is verifiable. You don't have to trust anyone's claims — you can check for yourself in about 30 seconds.

How to Do It

  1. Open the tool in your browser
  2. Open DevTools (F12 on Windows/Linux, Cmd+Option+I on Mac)
  3. Click the Network tab
  4. Clear the log (click the circle-with-a-line icon)
  5. Use the tool — paste text, upload a file, click generate
  6. Watch the Network tab

What You Should See

If the tool is truly local:

  • No new requests appear when you process data (or only static asset requests like fonts/CSS)
  • No POST requests to any API endpoint
  • No requests with your data in the payload

If the tool is sending data to a server:

  • You'll see POST or PUT requests appear when you click "process" or "generate"
  • Click on the request and check the "Payload" or "Request" tab — you'll see your data
  • The response will contain the processed result

Practice This

Seriously, go try it right now. Open any online tool you use regularly. Open the Network tab. Use the tool. You might be surprised. Some tools that claim to be "secure" and "private" make API calls with your data on every keystroke.

Once you know this trick, you'll never blindly trust an online tool again.

Browser Permissions: What to Allow, What to Block

Your browser asks for permissions for a reason. Here's a quick reference:

Generally Safe to Allow

  • Clipboard access — needed for copy/paste functionality in tools
  • File system access — only triggers when you explicitly pick a file
  • Download permission — needed to save processed files

Think Twice

  • Location — almost no legitimate tool needs this. If a converter asks for your location, that's a red flag.
  • Notifications — rarely useful for tools, mostly used for re-engagement marketing
  • Camera/Microphone — only for specific tools (video recording, audio processing). Deny by default.

Always Block

  • "Install as app" prompts from untrusted tool sites — this can enable background processes
  • Third-party cookie consent on tool sites — there's no reason a hash generator needs third-party cookies
  • Persistent storage requests unless you specifically want the tool to remember your settings

Browser Extensions to Consider

  • A good ad blocker eliminates tracking scripts that tool sites might load
  • HTTPS Everywhere (or your browser's built-in equivalent) ensures encrypted connections
  • A script blocker for advanced users who want fine-grained control over what executes

Cloud vs. Local: The Privacy Comparison

Here's a concrete comparison of how cloud-processed and locally-processed tools differ on privacy:

Aspect Cloud-Processed Locally-Processed
Data transmission Your data goes to a remote server Data stays in your browser
Processing location Server-side (you can't inspect it) Client-side (you can verify via Network tab)
Offline capability Doesn't work without internet Works offline (after initial page load)
Data retention Unknown — depends on their policy None — cleared when you close the tab
Third-party access Server operator, their hosting provider, potentially their analytics Only you
Verification You can't verify server-side deletion You can verify no data was sent
Speed for small files Slower (upload + process + download) Instant
Speed for large files May be faster for very large files Depends on your device's power
Account requirement Often required (for usage tracking/limits) Rarely required
Cost model Free tier with limits, then paid Often completely free

The pattern is clear: for the vast majority of use cases — especially anything involving sensitive data — locally-processed tools are the better choice.

A Practical Privacy Workflow

Let me walk you through how I actually use browser-based tools in a privacy-conscious way:

Scenario 1: Processing a Sensitive Document

  1. Open the PDF tool in an incognito/private window (prevents cookie tracking)
  2. Open the Network tab before doing anything
  3. Load my document
  4. Verify no upload requests appear
  5. Process and download
  6. Close the private window (clears all session data)

Scenario 2: Checking a JWT from Production

  1. Open a local JWT decoder (Network tab open)
  2. Paste the token
  3. Verify the decoded output shows the expected claims
  4. Verify zero network requests were made
  5. Done. The token never left my machine.

Scenario 3: Sharing a Photo

  1. Open an EXIF stripper tool
  2. Load the photo
  3. Verify metadata has been removed (the tool should show before/after)
  4. Download the clean version
  5. Share that version instead of the original

These extra steps take seconds, but they eliminate real risks.

The Bigger Picture: Why This Matters Now

We're in an era where data breaches are so common they barely make headlines anymore. Every piece of data you unnecessarily share with a third party is another surface area for a breach to expose.

But this isn't just about breaches. It's about a fundamental question: does a tool need your data to serve you, or does it just want your data?

A PDF merger doesn't need to see your tax return on its server. A hash generator doesn't need your file on its infrastructure. A password tool doesn't need to know what password you're testing. These operations are computationally trivial — your browser handles them effortlessly.

When a tool sends your data to a server for processing that could happen locally, it's a choice. The tool's developer chose to process server-side. And you should ask yourself why.

Sometimes the answer is innocent — legacy architecture, easier development, or they genuinely need server resources for heavy computation. But sometimes the answer is that your data has value, and they know it.

What I Actually Use

I've spent a lot of time building and curating tools that process everything locally. The result is a toolkit of 450+ browser-based tools — PDF processors, hash generators, encoders and decoders, image tools, text utilities, password generators, DNS tools, and more — where everything processes in your browser. No uploads. No accounts. No tracking.

I also built a news aggregator that pulls from 300+ RSS sources across the globe, organized by region and category, with no algorithmic filtering and no behavioral tracking. You see what's published, in order, from sources you choose.

The point isn't to plug my own stuff (okay, maybe a little). The point is that these tools exist. Privacy-first, browser-based alternatives exist for almost every common task. You just have to know to look for them — and now you know how to verify them.

Final Thought

The next time you're about to paste something into an online tool, take five seconds to open the Network tab. Those five seconds might save you from silently handing your data to a server you've never heard of, operated by a company you can't identify, with a privacy policy you'll never read.

Your browser is already the most powerful tool on your desk. Use it like one.

0 comments