DEV Community: Dinesh Rajendran

Stop Leaking Secrets: How to Decode JWTs Locally on Mac

Dinesh Rajendran — Sun, 16 Aug 2026 17:15:00 +0000

Every web developer has done it. You’re debugging a tricky authentication issue, pull a JWT (JSON Web Token) out of your browser's local storage, and paste it straight into jwt.io or some random "Free Online JSON Formatter" website.

We all know we shouldn't. That token often contains sensitive user roles, PII (Personally Identifiable Information), or administrative access privileges. Yet, we do it anyway because it's faster than writing a decoding script in the terminal.

Pasting sensitive production data into random web tools is a massive security risk. You have no idea if that site is logging your tokens, saving your JSON payloads, or scraping your credentials.

And recently, this exact habit blew up.

In late 2025, security researchers at watchTowr investigated popular code-formatting sites like JSONformatter.org and CodeBeautify.org. What they found was terrifying: they were able to scrape over 80,000 saved developer snippets that were left publicly searchable on these sites.

The leaked data included:

Administrative JWTs and API keys
Database and FTP credentials
CI/CD pipeline secrets
Production customer PII (addresses, phone numbers, emails)

When you paste a JWT into a third-party website, you are handing a bearer token to a server you do not control. Even if the site claims to be "client-side only," there is no guarantee the data isn't being indexed for a public "Share this snippet" feature.

Secure Alternatives: Decoding JWTs Locally

If pasting into random websites is off the table, what are your offline options?

1. Bash & `jq`

Parse the full JWT directly in your terminal. You can add this helper function to your ~/.zshrc or ~/.bashrc:

# Add to ~/.zshrc:
decodejwt() { 
  echo "$1" | jq -R -s 'gsub("\n"; "") | split(".") | {header: (.[0] | @base64d | fromjson), payload: (.[1] | @base64d | fromjson), signature: .[2]}'
}

# Usage:
decodejwt "YOUR_JWT_STRING"

2. Node.js

A tiny local script (decode.js) that outputs the structured token using Node's built-in buffers:

const token = process.argv[2];
const [header, payload, signature] = token.split('.');

console.log(JSON.stringify({
  header: JSON.parse(Buffer.from(header, 'base64url').toString()),
  payload: JSON.parse(Buffer.from(payload, 'base64url').toString()),
  signature
}, null, 2));

3. Python

A quick Python script that automatically handles Base64Url padding:

import sys, base64, json

def dec(s):
    return json.loads(base64.b64decode(s + '=' * (-len(s) % 4)))

h, p, s = sys.argv[1].split('.')
print(json.dumps({'header': dec(h), 'payload': dec(p), 'signature': s}, indent=2))

4. Browser DevTools Console (Offline)

Zero-install method. Open Chrome/Safari DevTools Console (F12) and run:

const decodeJWT = (t) => t.split('.').slice(0, 2).map(p => JSON.parse(atob(p.replace(/-/g, '+').replace(/_/g, '/'))));
console.log(decodeJWT("YOUR_JWT_STRING"));

The Best of Both Worlds: An Offline Native Tool

All of these CLI solutions are 100% secure. But context-switching to a terminal and writing commands every single time you need to check a token expiration date creates friction.

We need tools that are as fast as a web app, but 100% offline and secure.

That’s why I built L2Cache — a native macOS developer tool and smart clipboard layer.

Instead of sending your clipboard data to the web, L2Cache handles developer data directly on your Mac:

Instant JWT Decoding: Automatically detects when a JWT is copied and shows the decoded header, payload claims, and expiration in a clean popup with 1 click.
Local JSON Formatting: Beautify and syntax-highlight dirty JSON responses without third-party web tools.
100% On-Device: Built in native Swift + SQLite with zero telemetry.

Protect your tokens. Keep your credentials on your machine.

L2Cache is currently free on the Mac App Store for early access.

Why Your Mac Clipboard Needs 'grep': Regex Pattern Matching for Code & Tokens

Dinesh Rajendran — Sat, 15 Aug 2026 05:53:31 +0000

If you spend enough time in the terminal, you know that grep is a superpower. Need to find an error in a 10,000-line log? grep. Need to isolate a specific IP address? grep.

But what happens when that data leaves the terminal?

As developers, we copy dozens of highly specific strings every single hour:

UUIDs from database logs
Bearer tokens from API responses
AWS ARNs and resource identifiers
Hex color codes and environment variables

The default macOS clipboard holds exactly one item. If you copy a UUID and then accidentally copy a Slack message right after, that UUID is gone.

Even if you use a standard clipboard manager (like Maccy or Paste) that saves your history, you run into a major limitation: Searchability.

Standard clipboard managers rely on basic substring search. If you know you copied a UUID three hours ago, but you don't remember what the actual random string was, how do you search for it?

You can't.

Bringing Regex & `grep` to the Clipboard

This exact frustration is why I built L2Cache — a native macOS developer tool and smart clipboard memory layer. I wanted to bring the power of grep and a full regex matcher directly to my clipboard history.

Instead of typing a vague word and hoping the right token appears, you can search your clipboard history using raw regular expressions:

Find that UUID from this morning: ^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-...
Find an IPv4 address: \b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b
Find bearer tokens / JWTs: eyJ[A-Za-z0-9-_]+\.eyJ[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+

L2Cache uses a local SQLite database with FTS5 (Full-Text Search), meaning querying a history of 10,000+ clips with complex Regex takes milliseconds.

Built-in Smart Shortcuts

Because nobody wants to write regex for an IPv6 address or a JWT token from memory while coding, L2Cache includes built-in Smart Shortcuts.

By typing / in the search bar, you instantly get quick shortcuts for common developer patterns:

/uuid
/jwt
/ip
/email
/hex (Color codes)
/url

It transforms your clipboard from a dumb scratchpad into a queryable, grep-like database of your daily engineering workflow.

Stop losing your API keys and tokens in the abyss of your clipboard history.

L2Cache is 100% on-device and currently free on the Mac App Store for early access.

How to View and Search Mac Terminal Command History

Dinesh Rajendran — Thu, 30 Jul 2026 23:46:29 +0000

The Mac terminal remembers what you type, but finding that one complex curl command or ssh flag from last week can be incredibly frustrating. Here is how to use the built-in native command history, its limitations, and how power users never lose a command again.

If you spend any time in the macOS Terminal (or iTerm2/Warp), you know the feeling: you finally get a Docker build command or an ffmpeg script working perfectly with 10 different flags. A week later, you need to run it again, but you can't remember the flags.

macOS has built-in ways to recall these commands, but they have their quirks. Let's look at the standard ways to find your Mac terminal history, and then how to fix the workflow permanently.

1. Use the `history` command

The simplest way to see what you've typed recently is the native history tool.

Open your Terminal app.
Type history and press Return.

You will see a numbered list of your most recently executed commands. If you want to re-run a specific command, you can type an exclamation mark followed by the number (e.g., !142) and press Return.

💡 Tip: To search the list directly, you can pipe it into grep:
history | grep docker

2. Reverse Search (Ctrl + R)

Scrolling through a list is tedious. If you know a piece of the command, Reverse Search is much faster.

In your terminal window, press Ctrl + R.
Your prompt will change to (bck-i-search)':`
Start typing part of the command you remember.
The terminal will autocomplete the most recent match. Press Ctrl + R again to cycle backwards to older matches.
Press Return to execute it, or the right arrow key to edit it before running.

Where the built-in terminal history stops

While Ctrl + R is a lifesaver, the native .zsh_history file (where macOS stores these commands by default since Catalina) has several major flaws for modern developers:

History is isolated by tabs: By default, if you have multiple terminal tabs open, commands executed in one tab aren't immediately available in the history of another until you close the session.
No context or notes: You might find a complex git reset command, but you can't attach a note explaining why or when to use it.
No cross-device syncing: Your history on your MacBook doesn't sync to your iMac.
Truncation: By default, history files have limits (often 2,000 lines). Older golden commands eventually get overwritten.

⚠️ The gap: The built-in Mac terminal history is just a text file of raw commands. What developers really need is a way to capture, organize, and instantly retrieve complex CLI snippets without relying on brittle dotfiles.

3. Use a smart snippet and clipboard manager

Power users don't rely entirely on terminal history. Instead, when they write a command they know they'll need again, they save it to a snippet manager or rely on an intelligent clipboard history tool. This is where L2Cache comes in.

Never lose a terminal command

If you copy a command from StackOverflow or a coworker on Slack, L2Cache automatically saves it. If you build a complex script in your IDE, copying it means it's saved forever. You don't have to execute a command to keep it in your history.

AI-powered intelligence

L2Cache uses on-device Apple Intelligence to understand your snippets. It can automatically group your Terminal, Git, and Docker commands into smart albums. Instead of searching for an exact flag, you can search "that command to clear dns cache" and L2Cache finds it instantly.

Private by design

Terminal commands often contain AWS secrets, passwords, and API keys. L2Cache keeps your history strictly on your Mac. Sensitive copied items are detected automatically and locked behind Touch ID, ensuring your secrets don't sit in plain text.

Frequently Asked Questions

How do I see my command history on a Mac?

Open the Terminal and type the command history. This will print a numbered list of the most recent commands you have executed.

Where is the terminal history file located on Mac?

If you are Zsh (the default since macOS Catalina), the history file is located at ~/.zsh_history. For Bash users, it is located at ~/.bash_history.

How do I search my previous commands in Mac terminal?

Press Ctrl + R inside your terminal to open the reverse-i-search prompt. Start typing part of the command, and it will find the most recent match. Press Ctrl + R again to cycle through older matches.

Note: This article was originally published on L2Cache.

How to view clipboard history on Mac (and stop losing what you copy)

Dinesh Rajendran — Thu, 30 Jul 2026 01:34:21 +0000

Your Mac copies things brilliantly and remembers almost none of it.

If you've ever copied a link, gotten distracted, copied something else, and watched the first thing vanish — you've met the Mac's oldest quiet annoyance. By default, macOS keeps exactly one item on the clipboard. Copy again, and the previous one is gone for good.

There are a couple of built-in ways to see what's there, and one real way to stop losing things entirely. Here's all of them.

1. View the current clipboard in Finder

macOS has a clipboard viewer built into Finder. It shows the single most recent thing you copied.

Open Finder (or click your desktop).
In the menu bar, click Edit.
Choose Show Clipboard.

A small window shows your most recent copied item — text, or a filename if you copied a file. Genuinely handy for a quick "wait, what's on my clipboard right now?" check.

The catch: it's read-only, shows one item, and has no history. The moment you copy something new, whatever was there is unrecoverable.

2. Use the Spotlight clipboard history

Recent versions of macOS added a small clipboard history inside Spotlight — a step up, because it remembers more than one item for a little while.

Press ⌘ Space to open Spotlight.
Press ⌘ 4 (or click the clipboard section) to switch to clipboard history.
If prompted the first time, click Enable.
Scroll the recent items and press Return on one to copy it again.

For a lot of people this is enough to re-grab a link from a few minutes ago. If that's all you need, you're done — no extra software required.

But it's deliberately minimal, and once you lean on your clipboard for real work, you hit its edges fast.

Where the built-in tools stop

The Finder viewer and the Spotlight history solve "show me something recent." They don't solve "let me treat my clipboard as a memory I can rely on." Specifically:

No lasting history. Recent items only. The snippet from this morning, the address from last week — gone.
No real search. You can scroll, but you can't search your whole history for that API key or that paragraph from hours ago.
No finding images by content. You can't search a screenshot by the text inside it.
No organisation. One undifferentiated recent list — no grouping code, links, or images.
No protection for sensitive copies. Passwords, keys, and card numbers pass through with no special handling.

This isn't really a Mac-specific failing — it's a limit of what a single system clipboard was ever meant to do. And it matters more than it sounds, because of how much we actually copy.

How much do we really rely on copy-paste?

More than most people realise. When researchers mined the real usage data of over 20,000 developers working in an IDE, they logged millions of copy-and-paste events — and found people constantly move fragments between different tools and file types, not just within one document. Copy-paste isn't an occasional convenience; it's a primary way we shuttle information around all day.

Studies that logged everyday clipboard use found the same theme from the other side: people described copy-paste as a source of friction and lost work, because the one-slot clipboard quietly drops things and there's no way to get them back. The tool we lean on hundreds of times a day is the one with no memory.

3. Keep a full, searchable clipboard history with a clipboard manager

A clipboard manager runs quietly in the background and saves each thing you copy, so your history is always there to search and reuse.

Whichever one you choose, the things worth looking for are:

Unlimited, searchable history — full-text search across everything you've copied, ideally including text inside screenshots (OCR).
Local storage. Your clipboard sees passwords, 2FA codes, and private messages all day. Prefer a manager that keeps history on your Mac rather than syncing it to someone's server, and that hides sensitive copies (keys, card numbers) until you unlock them.
Some structure. Titles or grouping so your history isn't just a wall of near-identical rows.

Full disclosure: I build one of these — L2Cache — which is why I went down this rabbit hole. It keeps unlimited history locally, searches screenshots by their text, and auto-hides sensitive copies until you unlock them with Touch ID. It's free while in early access. But the criteria above apply to any manager you pick — Maccy is a solid free, open-source option too.

The short version

Quick peek at what's on the clipboard now: Finder → Edit → Show Clipboard.
Re-grab something from a few minutes ago: Spotlight → ⌘ 4.
Never lose a copy again: install a clipboard manager that keeps a full, searchable, local history.

The built-in tools show you what you copied recently. A clipboard manager gives your Mac the memory the clipboard never had.

FAQ

Can you see clipboard history on a Mac?
By default a Mac stores only the last item you copied — view it via Finder's Edit → Show Clipboard. Recent macOS versions add a short recent history in Spotlight (⌘ Space, then ⌘ 4). For a full, lasting, searchable history you need a clipboard manager.

Does macOS have a built-in clipboard history?
Recent macOS versions added a basic clipboard history in Spotlight that lets you re-copy a recent item. It doesn't offer unlimited history, full-text or OCR search, organisation, or protection for sensitive copies.

Is a clipboard manager safe to use?
It depends on the app. Because it records everything you copy, choose one that stores data locally rather than on a server, and that handles sensitive items carefully.