DEV Community: wayknow

Building a Privacy-First Cookie Editor: CHIPS, Interceptors & Auto-Cleanup in MV3

wayknow — Mon, 24 Aug 2026 06:27:15 +0000

CrumbKit is a free, open-source cookie editor for Chrome. We released v1.2 in August 2026 with three features that required non-obvious Manifest V3 implementation work: CHIPS partitioned cookie support, a Set-Cookie response interceptor, and scheduled auto-cleanup rules. Here's how we built each one — and what we learned.

Full disclosure: I built CrumbKit. Everything below is from the actual codebase — no marketing fluff, no hand-waving.

1. CHIPS Partitioned Cookies — The New Third-Party Cookie

Chrome is phasing out third-party cookies in favor of CHIPS (Cookies Having Independent Partitioned State). A partitioned cookie is scoped to a specific top-level site — two different websites can each have their own cookie with the same name and domain, but they're completely isolated from each other.

This is a big deal for cookie editors because it means the traditional dedup key — name + domain + path — is no longer unique. Without handling partitionKey, you'd silently overwrite or lose cookies.

How we implemented it

The change touched four layers:

Cookie normalization: We added partitionKey to the normalized cookie object:

function normalizeCookie(cookie) {
  return {
    name: cookie.name,
    value: cookie.value,
    domain: cookie.domain,
    path: cookie.path,
    // ... other fields
    partitionKey: cookie.partitionKey || null
  };
}

Deduplication: The dedup key now includes the partition key. Two cookies with the same name/domain/path but different top-level sites are treated as distinct:

const key = `${c.name}|${c.domain}|${c.path}|${c.partitionKey || ''}`;

Export formats: All six export formats had to be updated. JSON includes the full partitionKey object. CSV serializes it as a JSON string. Set-Cookie headers add the Partitioned attribute. Puppeteer scripts pass the partitionKey through. The key principle: partition data is never silently dropped.

UI: Partitioned cookies show a blue "P" badge in the cookie list. The edit form displays the top-level site as read-only text with a hint: "(CHIPS — set by server)". Users can't edit the partition key because it's determined by the browser, not the cookie itself.

What we learned

Chrome's chrome.cookies API returns partitionKey on partitioned cookies, but most cookie editor tutorials and existing tools don't handle it. CookieJar was the only competitor we found with full CHIPS support. The lack of awareness around partitioned cookies is a real gap — as Chrome rolls out CHIPS more broadly, tools that don't handle it will silently produce incorrect exports.

2. Set-Cookie Interceptor — Watching the Network

One thing we noticed: developers often want to see what cookies a server is setting via Set-Cookie response headers, but Chrome's DevTools buries this in the Network tab. We wanted a one-click way to see, inspect, and add intercepted cookies.

The MV3 challenge

In Manifest V3, you can't use chrome.webRequest.onHeadersReceived to modify requests. But you can use it to observe them. The key is the extraInfoSpec parameter:

chrome.webRequest.onHeadersReceived.addListener(
  (details) => {
    // details.responseHeaders contains Set-Cookie headers
    for (const header of details.responseHeaders) {
      if (header.name.toLowerCase() === 'set-cookie') {
        // Parse and store the intercepted cookie
      }
    }
  },
  { urls: ['<all_urls>'] },
  ['responseHeaders']
);

The ['responseHeaders'] extraInfoSpec tells Chrome to include response headers in the event. Without it, you only get the request.

Data storage

We store intercepted cookies in chrome.storage.session — a volatile store that's cleared when the browser restarts. This is intentional: intercepted cookies are transient data (they're what the server tried to set, not what's actually in the browser). The store is capped at 50 entries to prevent bloat.

The service worker runs as a persistent-ish background script (MV3 service workers can be terminated), so we use a keep-alive port pattern to maintain the interceptor connection when the popup is open.

What we learned

The chrome.webRequest API is read-only in MV3, which is fine for an interceptor — you're watching, not modifying. But there's a gotcha: service workers can be killed by Chrome at any time. The interceptor needs to re-register its listener when the service worker starts up, not just when the extension is installed. We handle this with a chrome.runtime.onStartup + chrome.runtime.onInstalled double-registration pattern.

3. Scheduled Auto-Cleanup — Chrome Alarms as a Cron Job

The auto-cleanup feature lets users set rules like "delete all advertising cookies every hour" or "delete cookies older than 30 days every Sunday." Rules run in the background via chrome.alarms.

How it works

Each rule has a schedule (in minutes), a target (domain, category, or age), and a list of matching cookies. When the user creates a rule, we call chrome.alarms.create() with the interval. When the alarm fires, the service worker:

Gets all cookies via chrome.cookies.getAll({})
Filters by the rule's target (domain pattern, category, or age threshold)
Deletes matching cookies via chrome.cookies.remove()
Optionally sends a chrome.notifications notification

Classification in the service worker

Here's the tricky part: the popup's cookie classification uses a bundled tracking-domains.json file loaded via chrome.runtime.getURL(). But service workers can't access the DOM, so chrome.runtime.getURL() doesn't work the same way.

Our solution: the service worker uses inline classification — the same regex patterns as the main classification module, but hardcoded into the service worker. This avoids loading the JSON file in the background context. Domain-based matching (checking if a cookie's domain appears in the tracker list) is available when creating rules in the options page, where the DOM is accessible.

What we learned

chrome.alarms is Chrome's built-in cron job. It's reliable, survives service worker restarts, and is exactly the right tool for background tasks. The minimum interval is 1 minute, which is fine for cookie cleanup. One caveat: alarms don't fire while Chrome is closed. If the user has a "daily" rule and doesn't open Chrome for a week, it only fires once when they open the browser. This is acceptable for cookie cleanup — the cookies will still be there waiting to be deleted.

4. Six Export Formats — The Keyword Spam Trap

This isn't a technical challenge, but it's a lesson we learned the hard way. CrumbKit supports six export formats: JSON, Netscape, cURL, CSV, Puppeteer, and Set-Cookie headers.

When we submitted v1.2 to the Chrome Web Store, the listing was rejected for keyword spam. The automated审核 system flagged the enumeration of six format names in two places — even though every format name corresponds to a real feature. The system interpreted the comma-separated list of technical terms as SEO keyword stuffing.

Fix: reduce any format enumeration to three names maximum, use "and more" for the rest, and never repeat the same list in two places within the description. The CWS automated审核 treats repeated lists of technical terms as spam, regardless of whether they're real features.

The Bigger Picture: Why Free Matters

Every cookie editor on the market is either abandoned (EditThisCookie), paid (CookieJar at $4.99/month), or has ads (Cookie Editor). None of them hit all three: free, open source, and actively maintained.

CrumbKit is free because it's an acquisition tool for our product family. We make money from SnapMark and ClearJSON. CrumbKit is how developers discover WayKnow. The cookie editor market has no validated paid demand — EditThisCookie had 3M free users for a decade, Cookie-Editor has 2M free users. Making CrumbKit free maximizes reach.

The entire extension is under 85KB of pure vanilla JavaScript. Zero frameworks, zero build step, zero dependencies. The chrome.cookies API hasn't changed since 2016. This thing will run for years without maintenance.

Try It

CrumbKit is free, MIT open source, and on the Chrome Web Store and Edge Add-ons:

If you're building a Chrome extension and run into MV3 issues — especially with service workers, chrome.webRequest, or chrome.alarms — the CrumbKit codebase is a working reference. MIT licensed, so steal freely.

CrumbKit is part of the WayKnow product family — privacy-first browser tools with zero tracking and no sign-up required.

EditThisCookie Was Removed. A Malware Clone Took Its Name. Here's What to Use

wayknow — Thu, 13 Aug 2026 06:44:17 +0000

EditThisCookie had millions of users. It was the default answer to "how do I edit cookies in Chrome?" for a decade. Then Chrome's Manifest V2 platform was retired, the extension never migrated, and in late 2024 it disappeared from the Chrome Web Store.

What happened next is the part nobody warned anyone about: a malicious clone took its name.

The clone

An extension called "EditThisCookie®" — note the ®, the dead giveaway — appeared on the store and got downloaded by tens of thousands of people searching for the original. Security researchers confirmed it was malware: obfuscated code, phishing and ad-injection mechanisms, and the ability to steal sensitive data, especially when you were logged into Facebook.

Google eventually removed it. But think about what that means: people who just wanted to edit a cookie — the most innocuous developer task imaginable — installed malware, because the tool they'd trusted for years vanished without a farewell and the search results were a minefield.
That's the real lesson of the MV2 migration: a cookie editor is a session-instrument tool. It has access to your cookies on every site. When an unmaintained cookie editor dies, its name becomes a honeypot. Whatever you install next needs to be auditable.

The checklist I now apply to any cookie editor

MV3-native — if it's not built for Manifest V3, it's already dead, just not buried
Open source — a cookie editor that you can't audit is a liability you're choosing
Recent updates — check the store's "last updated" date
No lookalike branding — any extension that brands itself as "the replacement for the dead original" deserves extra scrutiny
The right permissions — cookies is expected; broad host permissions without a clear reason are not

What to actually use in 2026

I tested the current field so you don't have to re-run this gauntlet. Full disclosure: I built one of these (CrumbKit), so take my ranking with that in mind — I've flagged where mine is genuinely weak.

Chrome DevTools — the zero-install baseline. Right-click → Inspect → Application → Cookies. Fine for the occasional edit, painful as a daily workflow. No search across domains, no. export/import.

CookieMate — open source (MIT), MV3-native, and the one feature that matters most for ex-EditThisCookie users: it imports EditThisCookie's JSON backups directly. If you have an old export, this is the smoothest migration. Simple editor, no fancy extras.

CookieJar — the feature-rich contender: cookie classification, per-site privacy scores, profiles (dev vs. prod cookie sets), multiple export formats, CHIPS partitioned-cookie support.
Free tier plus a paid Pro tier. Honestly the closest thing to "EditThisCookie with a 2026 paint job."

CrumbKit — the one I built: everything free, MIT open source, zero network requests. Where it genuinely beats the others: a Set-Cookie interceptor that shows you which cookie a server just set (in the response headers) and adds it with one click — no other tool in this list does that. Plus scheduled auto-cleanup, 6 export formats (JSON, Netscape, cURL, CSV, Puppeteer, Set-Cookie headers), batch editing, profiles, and a privacy score. Where it loses: it's younger than the alternatives and I'm a solo maintainer — if you only edit a cookie once a month, DevTools is genuinely enough.

Migrating your old backups

If you still have an EditThisCookie export: CookieMate imports its JSON format directly, and CrumbKit imports JSON and Netscape. If you don't have a backup, re-login to your sites — the old cookies are gone either way.

The takeaway

The MV2 migration didn't just break extensions — it created a trust vacuum that scammers filled within weeks. The defense isn't "find the most popular replacement." It's "find the one you can audit." Open source, zero telemetry, and a recent update date beat a familiar name every time.

If you've got a horror story from the EditThisCookie aftermath — or a cookie workflow you can't live without — drop it in the comments. I'm building feature lists off those answers.

# CSS Scan Has 20,000 Users — Here's the Opportunity Everyone's Missing

wayknow — Fri, 07 Aug 2026 08:34:43 +0000

I spent last week digging into the CSS inspection tool market. I wanted to understand why the most recommended paid extension in this category — CSS Scan — has 20,000+ users despite charging a premium price for what is, at heart, a single-purpose utility.

Here's what I found.

The Numbers

CSS Scan is a Chrome extension that lets you hover over any element on a page and instantly copy its computed CSS. It's the tool front-end developers recommend on Hacker News, in blog roundups, everywhere.

Version: 4.5, last updated April 2026 (actively maintained)
Users: 20,000+ professional developers (their claim)
Price: $120 one-time license (list price — frequently discounted; 42% off at the time of writing, bringing it to $69), limited to 3 browsers simultaneously

So we have a category leader that's actively maintained, has real paying users, and a price tag that feels detached from what the tool actually does. That's the pattern I look for.

What Users Actually Complain About

The recurring theme across the store reviews is price, not bugs. The functionality is praised — hover-to-copy genuinely saves hours when you're trying to match a design or reverse-engineer a layout. But a one-time payment in the $69–120 range, license-activated with a 3-browser device limit, creates exactly the "do I really want to pay this much" hesitation that kills impulse conversions.

A browser extension that reads computed styles with a standard API — no server, no infrastructure, no recurring cost — priced like a design tool suite. That's the mismatch.

The Free Alternatives: Why None of Them Won

If the price is the problem, why hasn't a free alternative taken the crown? I looked at all of them.

| Tool | Price | The Problem |
|------|-------|-------------|
| CSSViewer | Free | The classic hover-view tool. Old, minimal updates — styles can break on modern pages |
| CSS Peeper | Free | The original big name in this space. Now ad-supported; users have turned on it |
| CSS Peek | Free | Nice and tiny, but no momentum — a curiosity, not a category player |
| Tailwind CSS Scan & Copy | Free | Focused on Tailwind conversion only, almost no distribution |
| ExtractCSS | Free | A newer free option with component extraction, but it's early — no track record |
| CSS Scanner (not Scan) | Free | A handful of users. Effectively dead on arrival |
| SuperDev Pro | Free tier | 50+ tools in one sidebar — a Swiss army knife, not a focused CSS tool |

The pattern is clear: everyone competing with CSS Scan is either free-but-neglected, ad-driven, or a side feature of a bigger product. Nobody has done what CSS Scan did — a focused, polished, paid hover-to-copy tool — at a price that doesn't feel insulting.

The One Weird Gap

Here's the thing that stood out to me most: the two paid players in this niche are CSS Scan at $69–120 (depending on the promo) and UI-Ray at $39. Both are one-time purchases. Both are locally processed. Both are functionally similar to each other.

Neither has moved down-market. There's no $15–19 version of this tool with modern polish, no-subscription, local-only. The demand is validated — 20K users proves developers pay for this. The price anchoring is proven — the $69–120 band is "established." That leaves the $19 band completely open.

And if you've ever shipped a Chrome extension, you know hover-detection + overlay + computed-style extraction is a weekend project with a good foundation — not a six-month engineering effort. The barrier to entry is low, which makes the fact that nobody's done it yet more surprising.

So I Built It

Update: this article got a bit of attention, and I decided to stop analyzing and actually ship it.

Full disclosure: I built the thing I described. CSSPick is live on the Chrome Web Store now — a hover-to-copy CSS inspector at $19 one-time, no subscription, everything computed locally in your browser. Same core interaction as CSS Scan: hover, click, copy — with
the CSS grouped into Color / Typography / Spacing / Size & Box / Background / Border & Shadow / Layout so you can grab just what you need.

Why $19? Because the pricing itself is the objection — and a one-time purchase at $19 hits the "sure, why not" range where utility tools actually convert. I'd rather have 500 paying users at $19 than 100 at $69, and so would the market, apparently.

It also asks for minimal permissions — activeTab + storage + scripting, no "access to all your data on all websites" warning when you install it. Free version is genuinely useful (inspect + copy single properties); Pro unlocks Copy All CSS and Copy Selector.

If you try it and the analysis was wrong somewhere — or the tool is missing something — tell me in the comments. Especially tell me: what's the CSS property or workflow you copy by hand every single day? That's the feature list I want to hear about next.

Build update

This article identified an opportunity: CSS Scan has 20K users but a 3.5★ rating, and users complain about the $95 price. I built
CSSPick to fill that gap.

$19 one-time (vs $95)
Free tier: view + copy single properties
Pro: Copy All CSS + Selector
100% local, minimal permissions, no tracking

Product Hunt launch today · Chrome Web Store
website

I Tested Every JSON Viewer After the Formatter Scandal. Here's What I Found.

wayknow — Thu, 06 Aug 2026 07:25:53 +0000

Remember JSON Formatter? The Chrome extension with 200K+ users that auto-formatted JSON in your browser? In mid-2026 it went closed-source, partnered with GiveFreely, and started injecting geolocation tracking plus donation popups into checkout pages. The developer's defense was "it's for charity." The community's response was a collective "uninstall immediately."

I'm a developer. I look at JSON all day — API responses, config files, debug dumps. I needed a replacement. So I tested every major JSON viewer on the market.

The Contenders

JSON Formatter (arnav-kr) — The spiritual successor

This is the most popular open-source fork. 60+ themes, collapsible toolbar, keyboard shortcuts for everything.

Good: Truly open source. Actively maintained. Works offline. The free tier is generous.

Catch: No large file support. Above ~5MB it starts to struggle. No JWT decoding, no advanced export formats. If you just need basic formatting, it's perfect. If you work with bigger data, keep reading.

JSON Viewer Pro (PatilWeb) — Power user's choice

300K+ users, 4.7 stars. Tree view, chart view, JSONPath with autocomplete, custom CSS. It's the most feature-rich free option.

Good: Breadcrumb navigation is genius. Chart visualization for numeric data. Active development (v7.1 as of October 2025).

Catch: Closed source. Smart UI is cool but sometimes doesn't trigger when you expect it to. Heavy — noticeably slower page loads on large JSON.

JSON Alexander (Wes Bos) — The celebrity pick

Built by Wes Bos specifically in response to the Formatter scandal. Clean, minimal, trustworthy by association.

Good: Dead simple. Interactive tree, path inspection, dark/light/auto themes. Built by someone the community trusts.

Catch: Feature-light compared to others. No search. No export. No large file handling. It's a formatter, not a toolkit.

JsonDiscovery — The different one

Instead of adding a toolbar, it transforms the entire page into an interactive explorer. Tree, table, and list views. Right-click context menus for copying paths and objects.

Good: Highest rated (4.88). Innovative UX. JORA query language with autocomplete.

Catch: Takes over the entire page — no way to see raw JSON side-by-side. Learning curve for the query syntax. Closed source.

Firefox Built-in — The one you already have

If you use Firefox, you already have a JSON viewer. Collapsible tree, syntax highlighting, search. It's fine.

Good: Zero install. Zero trust issues (it's the browser). Always there.

Catch: Chrome users are out of luck. No themes. No copy-to-path. No export. It's a viewer, not a tool.

The Pattern

Dealbreaker	arnav-kr	PatilWeb	Wes Bos	JsonDiscovery	Firefox
No large file support	✅		✅		✅
Closed source		✅		✅
Heavy / slow		✅
Too minimal	✅		✅		✅
Phones home?	❌	?	❌	?	❌

No tool was: fully open source + handles large files + privacy-guaranteed + feature-complete.

So I Built One

After two weeks of switching between tools depending on what I was doing, I built ClearJSON.

What it does

Formatting & Viewing:

Auto-detects JSON, JSON-LD, JSON:API, NDJSON — any JSON-like content type
Collapsible tree view with indent guides, element counts, and depth indicators
Syntax highlighting for all 7 JSON token types (strings, numbers, booleans, null, keys, punctuation, links)
10 free themes with automatic dark/light system following
Click-to-copy values, right-click for JSONPath or subtree
Auto-detected clickable links, hover-to-preview images (PNG/JPG/GIF/SVG/WebP)
Line numbers in raw view, status bar with node count/max depth/file size/parse time

Privacy — the reason I built it:

Zero network requests for free users. Not one. The extension has no analytics, no tracking, no accounts, no ads.
The Pro license verification is the ONLY network call, and only when activating a key.
All processing (parsing, formatting, rendering, search) happens on your device.

Pro features ($2.99/month, cancel anytime):

Virtual scrolling for 500 MB+ JSON files (Web Worker + streaming parser)
JWT auto-decode — detects eyJ... tokens, inline displays header + payload, highlights expiry
Regex search with match navigation and full-document highlighting
Multi-format export: CSV, TSV, YAML, TypeScript type definitions (recursive inference)
20 additional premium themes (Monokai, Dracula, Nord, One Dark, Solarized, Catppuccin, Tokyo Night, Gruvbox, and more)
Custom keyboard shortcuts

The Tech Stack (for the curious)

Vanilla JS + IIFE module pattern. Zero frameworks, zero build steps. 28 files, ~59KB zipped.
CSS variable-driven theming. 30 themes defined as key-value pairs, injected at runtime via <style> tag.
Streaming parser (Pro): Web Worker receives raw text in chunks, builds a flat node array, main thread renders only visible rows via virtual tree. 10,000+ nodes renders in under a second.
JWT decode: Regex match → Base64Url decode (handles - → +, _ → /, missing padding) → JSON.parse header/payload → inline render in tree view.
TypeScript type generation: Recursive inference with duplicate structure deduplication. Generates proper interface blocks for nested objects.
License server: Cloudflare Workers + D1 (SQLite). 7-day cache + offline fallback. Only called during key activation/verification.

Honest Limitations

Chrome/Edge only. No Firefox version yet (Manifest V3 vs V2 differences).
Free tier limited to 2MB files. This is a deliberate choice — virtual scrolling is complex infrastructure, and it's how the Pro tier makes money.
No JSONPath query. JSON Query Tool and JSON Viewer Pro already do this well for free. I'm not going to build a worse version just to check a box.
No JSON Diff. Same reason — Just JSON and JsonKing do it better, for free.
Still early. ~43 installs as of writing. The product is solid, the user base is not.

Why $2.99/month?

JSON viewers have exactly zero marginal cost. No servers, no storage, no API calls — which is precisely why an honest subscription works: the money funds maintenance and new features, never servers and never data harvesting. I spent two years selling ClearJSON as a one-time purchase and watched the market move past it — lifetime plans have quietly disappeared from paid extensions, and subscription is what users actually support. $2.99/month, cancel anytime, free tier stays fully functional.

Try it: ClearJSON on Chrome Web Store | Microsoft Edge Add-ons

Source: github.com/wayknow/clearjson (MIT)

What are you using to view JSON? Did I miss a good one?

I Tested Every Chrome Screenshot Extension. Here's Why I Built My Own.

wayknow — Tue, 04 Aug 2026 09:02:28 +0000

I Tested Every Chrome Screenshot Extension. Here's Why I Built My Own.

I take a lot of screenshots. Bug reports, design feedback, tutorial steps, competitor research — easily 20+ a day. So I went looking for the perfect Chrome screenshot extension. What I found was surprising.

The Contenders

I tested every major screenshot extension with 10,000+ users on the Chrome Web Store. Here's what I found:

GoFullPage — Great at one thing, useless at everything else

GoFullPage does exactly what the name says: full-page screenshots. It scrolls, stitches, and spits out a long image. 10/10 for that one feature.

But you can't capture just the visible area. You can't select a region. There are no annotation tools on the free tier. Want to draw an arrow? Pay up. It's a one-trick tool in a category that demands versatility.

Price: $1/month. Seems cheap, but over 3 years that's $36 for something that can't even draw a rectangle.

Awesome Screenshot — Awesome features, concerning privacy

Feature-wise, Awesome Screenshot is the most complete. Screenshots, screen recording, annotations, cloud sharing. It does everything.

But here's the catch: your screenshots go to their cloud. You need an account. The free tier nags you constantly. And the price? $72/year. For a screenshot tool. Over 3 years you're paying $216 — more than a Microsoft Office subscription.

Also, the extension is heavy. Like, noticeably-slows-down-your-browser heavy. No thank you.

FireShot — The one that broke my heart

FireShot was the closest to what I wanted. Full-page capture, annotation tools, PDF export, one-time purchase. I almost bought it.

Then I noticed: the paid version still has a watermark. "Captured by FireShot" sits at the bottom of every screenshot. You paid $40 and they still stamp their brand on your work.

Also: their PDF output is bizarrely bloated. A 3-page document hit 2.9MB. Their tech is aging, and there are rumors they're killing the lifetime option to go subscription-only.

Lightshot — The ticking time bomb

Lightshot is simple and fast. Click, drag, annotate, done. 3.2★ on the Web Store.

The problem? Screenshots uploaded to their server are automatically deleted after a few months. Their privacy policy is vague about what "deleted" means. Also, it completely breaks on Google Docs. If you're a heavy Docs user, Lightshot is unusable.

Nimbus — Feature overload

Nimbus has everything: screenshots, screen recording, video editing, cloud storage, team collaboration. It's trying to be an entire creative suite inside a browser extension.

The result? A cluttered interface that takes 10 clicks to do what should take 2. The free version adds a watermark. The paid version is $60/year. It's overengineered for what most people need.

The Pattern

After testing all five, a pattern emerged:

Dealbreaker	GoFullPage	Awesome	FireShot	Lightshot	Nimbus
Missing core modes	✅			✅
Cloud upload forced		✅		✅	✅
Paid still watermarked			✅		✅
Subscription only	✅	✅			✅
Bloat / performance		✅			✅

No single tool was: fully-featured + local-first + watermark-free + one-time purchase.

So I Built One

I'm a developer. I know my way around the Chrome extension APIs. How hard could it be?

Turns out: harder than expected. But also extremely satisfying. Here's what I built:

SnapMark — Screenshots + Annotation, 100% Local

7 capture modes:

Visible area (one click, instant)
Full page (auto-scroll with overlap blending for seamless stitches)
Region selection (drag to select, real-time W×H display)
Smart element selection (hover to detect DOM elements, click to capture)
Timer capture (3/5/10 second countdown — for dropdowns and tooltips)
Clean & Capture (remove ads, banners, cookie popups before capturing)
Batch capture (paste URLs, auto-capture up to 20 pages)

8 annotation tools:

Arrow, Rectangle, Ellipse, Text, Freehand, Blur/Mosaic, Step Numbers (①②③), Crop
Full IME support for Chinese, Japanese, and Korean text input
17 system fonts, 9 font sizes (12–144px)

What makes it different:

Zero data leaves your browser. Screenshots, annotations, exports — all local.
No account, no sign-up. Install and go.
Free tier is genuinely complete. 4 capture modes, all annotation tools, PNG export. No watermark on screenshots.
Pro is $39 one time. No subscription. One payment, lifetime access.

The Tech Stack (for the curious)

Vanilla JS + ES modules. Zero frameworks, zero build steps. The entire extension is ~80KB zipped.
Canvas 2D annotation engine. Full-resolution rendering (canvas.width = image.naturalWidth), CSS handles display scaling. Mouse coordinates are transformed from CSS space to canvas space.
Full-page stitching: 50px overlap between segments + Canvas gradient blending (destination-in composite) to eliminate visible seams.
IME text input: Transparent <textarea> overlaid on canvas during text editing. Same approach Figma and Excalidraw use. Handles CJK composition events natively.
PDF export: Hand-rolled Uint8Array builder. No PDF library. Minimal output size.
License server: Cloudflare Workers + D1 (SQLite). Optional — only for Pro verification. Free users never make a network request.

Honest Limitations

Chrome-only right now. Firefox and Edge versions are on the roadmap.
No screen recording. (Competing with Loom is a different product category.)
No cloud sharing by design. If you need team collaboration with shared links, this isn't your tool.
Still early. v1.4.0 just shipped. There will be bugs.

Why $39 Lifetime?

I hate subscriptions. Every screenshot tool charging $5-10/month is extracting way more value than they provide. The marginal cost of a screenshot tool is essentially zero — no servers, no storage, no API calls. Charging monthly for it feels dishonest.

$39 once, use it forever. If the math works, great. If not, the free tier is genuinely useful and I'll keep improving it regardless.

Try it: SnapMark on Chrome Web Store

Website: wayknow.tech/snapmark

Feedback welcome — especially on the annotation UX. What would make you switch from your current tool?

I Built a JSON Formatter After the Original Started Injecting Ads — Here's What I Learned

wayknow — Thu, 30 Jul 2026 07:57:39 +0000

A few months ago, the most popular JSON formatter Chrome extension (2M+ users) was sold. The new owners immediately closed the source, injected affiliate ads, and started tracking user
geolocation.

HN exploded. Developers fled. Five open-source alternatives appeared within a year.

But here's the thing that bothered me: all of them are free, and none of them have a business model.

This is exactly how we got here. A maintainer burns out, sells to the highest bidder, and 2 million users wake up to ads in their browser. The cycle just repeats.

So I built ClearJSON (https://wayknow.tech/clearjson.html). Not because the world needed another JSON formatter — but because it needed one that wouldn't betray its users.

What makes it different

100% local, verifiable in DevTools. Open the Network tab — there's nothing. Never connects to a server, never sends data anywhere. I can't track you even if I wanted to.

Handles 100MB+ JSON files without freezing. Every free alternative calls JSON.parse() on the main thread. That works fine at 2MB, not at 100MB. ClearJSON does the parsing in a Web Worker so
the browser stays responsive. This was the hardest part to build and the reason most alternatives skip it.

JWT auto-decoding. Half the reason I open JSON is to inspect JWTs. Click a token and it decodes the header + payload inline.

MIT license. Even if I disappear tomorrow, anyone can fork it. The license actually protects users this time.

The business model question

I charge $29 one-time for Pro (large files, JWT, exports, more themes, custom shortcuts). The free tier has everything most people need.

A few people have asked: "Why not just make it free? There are five free alternatives."

Because "free" is how the last one got sold. A one-time purchase with no recurring server costs means there's no incentive to sell out. No investors to please, no data to monetize. Just a
tool that works.

The MCP server (npx -y clearjson-mcp) is also MIT licensed — so AI agents can format and validate JSON directly, including large files that would crash other MCP tools.

What I'd do differently

Start marketing before shipping. I built the whole thing, launched, and then started thinking about distribution. Should have been building an audience in parallel.
The "betrayal" story is a hook, not a business. People upvote the drama, but they don't automatically buy the product.
CWS organic discovery is slow. Without reviews and installs, you rank on page 10. External traffic (blog, Reddit, HN) is the only way to bootstrap.

Links

Chrome Web Store (https://chromewebstore.google.com/detail/clearjson/bgcicghmdpefapfdeghgealacphkgobk)
GitHub (https://github.com/wayknow/clearjson) (MIT)
MCP Server on npm (https://www.npmjs.com/package/clearjson-mcp)
Full comparison of JSON Formatter alternatives (https://wayknow.tech/blog/json-formatter-alternatives.html)

Building privacy-first developer tools — no accounts, no tracking, one-time purchase

wayknow — Tue, 28 Jul 2026 06:12:25 +0000

Hey DEV! I'm building the WayKnow family of developer tools after getting frustrated with the state of browser extensions.

The origin story: The most popular JSON Formatter extension (2M users) was sold and started injecting ads + tracking geolocation. EditThisCookie (3M users) got killed by Manifest V2. I realized there was a gap for tools that are genuinely private, open source, and don't force subscriptions.

So far I've shipped:

ClearJSON — JSON viewer that handles 100MB+ files without crashing, $29 lifetime
SnapMark — Screenshot + annotation tool, $39 lifetime (vs competitors at $72/year)
CrumbKit — Free cookie editor, MIT licensed, minimal permissions
ColorPeek — macOS color picker for developers, $19 lifetime

Everything is local-first, MIT licensed, one-time purchase. No backend, no user accounts, no telemetry.

Happy to answer questions about building Chrome extensions, dealing with CWS review, or the buy-once business model!