JSON Toolkit

JSON Browser Extensions and Privacy: One Incident, Four Permission Audits

Bottom line: A JSON formatting extension with 200,000+ users started injecting tracking scripts overnight, and the root cause is the <all_urls> permission combined with an automatic-update trust model. This article walks the incident timeline, measures real permission gaps across four open-source repos, and gives a five-step pre-install checklist plus a trust comparison of four tool shapes.

Advanced~5 min readPublished 2026-11-21Updated 2026-11-21
Auditing a JSON browser extension's manifest permissions before installing

A formatting extension that holds the <all_urls> permission can read every page you open in the browser — and how it uses that permission tomorrow depends on an automatic update you do not control.

One: the incident — what 200,000 users installed changed its mind

In mid-2026, one of the most popular JSON formatting extensions on Chrome (200,000+ users) went through a chain of changes: it first went closed-source, then struck a partnership with the data partner GiveFreely and began injecting geolocation tracking scripts and donation popups into the checkout pages users browsed. The developer's public defense was that it was "for charity," and the community responded with a collective uninstall. A November 2026 retrospective on dev.to laid out this timeline and reviewed the replacement tools in detail.

The incident deserves a pause from every developer: why does a tool that "just makes JSON pretty" have the ability to inject scripts into shopping pages? The answer is not in a single malicious commit — it is in the extension permission model itself. Worse, extensions update automatically: the version you audited on install day may not be the code running three months later. Closed-sourcing plus a data partnership is a complete case study of that trust chain breaking.

Two: why a content script's reach is inherently larger than a web page's

Per MDN's definition, an extension's content script can read and modify the DOM and data of the page it is injected into, and the injection can happen as early as document_start — before the page's own scripts run. A JSON extension that requests <all_urls> theoretically holds that power on every page of every site: the API response you paste into an internal admin panel, the intranet system's data — all of it is visible.

That is a fundamentally different trust model from an online web tool. A web tool's capability boundary is its own domain; the data you paste exists only in that tab. An extension's boundary is the entire browser. So the first question about an extension is not how its UI looks, but which permissions it requests and which pages it touches, at what moment.

Three: auditing four open-source repos — same job, an order-of-magnitude gap

Everything an extension can do is written in its manifest.json. I picked four JSON extensions with public repositories and, on 2026-11-21, read each repo's HEAD manifest directly, extracting three field groups: permissions, host_permissions, and content_scripts. Here is what they ask for:

Repository (stars / license / last push) Manifest permissions host_permissions content_scripts
callumlocke/json-formatter (4,136★, BSD-3, 2026-09) MV3 storage, unlimitedStorage, webRequest *://*/* + <all_urls> two entries, both <all_urls>, one at document_start
arnav-kr/json-formatter (9★, MIT, 2026-05) MV3 storage, unlimitedStorage *://*/* + <all_urls> one entry, <all_urls>, document_start
zalando-incubator/bro-q (84★, MIT, archived since 2020) MV2 tabs, activeTab, http://*/*, https://*/*, storage, alarms (declared inside permissions) one entry, <all_urls>, document_start
oppoic/JSONViewer (54★, MIT, 2026-09) MV3 storage only none none

The audit reproduces in two steps: pull the manifest path from raw.githubusercontent.com (directory layouts differ, so search the file tree for manifest.json first), then extract the three field groups:

# Once you know the manifest path, one command shows the whole permission surface
curl -sS "https://raw.githubusercontent.com/callumlocke/json-formatter/HEAD/ext/manifest.json" \
  | python3 -c "
import json,sys
m=json.load(sys.stdin)
print('permissions     :', m.get('permissions'))
print('host_permissions:', m.get('host_permissions'))
print('content_scripts :', [(c.get('matches'), c.get('run_at')) for c in m.get('content_scripts',[])])
"

Reading the four results side by side is revealing. For the same job — "format JSON" — the most conservative implementation needs a single storage permission and zero content scripts (the JSONViewer route: nothing renders until the user opens it manually). The mainstream implementations request <all_urls> and inject at document_start on every page, because they must take over response rendering the instant you open a link: the better the UX, the wider the permission surface. The callumlocke build additionally declares webRequest (read-only observation under MV3), and bro-q still carries an MV2 manifest, where tabs plus all-sites URL permissions is the old wide-permission style — and the archived repo means those permissions will never be tightened again.

Note that nobody here is "guilty": <all_urls> plus document_start is the necessary price of the auto-formatting product shape. What you audit is not the width of the permissions alone but the product of three factors — permission width × maintenance transparency × update control.

Four: a five-step pre-install check, five minutes

  1. Read the permissions, not the rating. Expand the "Permissions" section on the store page and ask, item by item, whether the feature really needs it. Anything beyond "read and change your data on all websites" for a JSON tool — reading browsing history, managing downloads — needs a one-sentence justification, and if there isn't one, pick another extension.
  2. Check open-source status and commit activity. If a source repository exists, look at the last commit date, the license, and issue response speed. The extension in the incident went rogue right after closed-sourcing — closed source is not inherently evil, but it removes your only ex-ante audit tool.
  3. Look for an ownership change in version history. An extension's "developer" field can change; a long-time maintainer suddenly handing over, or a rating curve suddenly sinking, are both signals. The "permission changes" history on the store page is worth a scroll.
  4. Verify data flow with the Network panel. After installing, open DevTools, paste a JSON payload with marker fields, and watch for requests to third-party domains during formatting. The same method applies to online tools — see does online JSON formatting upload your data.
  5. Try it offline. A purely local formatter should keep working with the network disconnected. If it dies offline, rendering depends on a remote service, and your data crossed the network stack at least once.

Five: what MV3 tightened, and what it did not

Chrome's MV3 replaced persistent background pages with on-demand service workers, banned remotely hosted code, and demoted webRequest to read-only — all real reductions in attack surface. But two things did not change: extensions can still request <all_urls> host permissions, and content scripts can still inject into every page at document_start. In other words, the permission-surface differences in the audit table above remain fully valid in the MV3 era. Treating "MV3 = safe" as a free pass is the most dangerous mistake this incident leaves behind.

Six: trust models of four tool shapes

Shape Data boundary Auditability Best for
Browser extension The whole browser (permission-dependent) Requires open source + traceable updates Frequent viewing of non-sensitive API responses
Online web tool The current tab Network panel + offline test Occasional use, after verification
Desktop editor (VS Code etc.) Local files Fully local Sensitive data, large files
CLI (jq etc.) Local files Fully local Scripted, batch processing

The same formatting need carries completely different trust costs in each shape. For JSON containing customer data, secrets, or intranet API responses, desktop editors and CLIs are the zero-network-exposure baseline; if you use an online tool, run checks 4 and 5 first; reserve extensions for the few that are small-permission, open-source, and actively maintained.

Seven: turn auditing into a habit

Three closing points. First, extension trust has an expiry date: this incident's timeline (closed-source → partner injection → collective uninstall) can replay on any popular extension, so re-run the five-step check on critical tools every six months. Second, evaluate permissions before features; for a broader selection table see JSON formatter tool comparison, and if your work is about reading structure rather than editing data, see JSON visualization tools. Third, the handling rule for sensitive JSON is one line: keep the data inside a boundary you have already audited — your machine or a tab, not the entire browser.

FAQ

Is the <all_urls> permission always dangerous?

No. Auto-formatting extensions must take over rendering early in the page load, so <all_urls> plus document_start is a functional prerequisite. What is dangerous is the combination of wide permissions, closed source, and no audit. Read the three manifest field groups before installing and the risk turns from "unknown" to "known."

How do I check the permissions of an installed extension?

Open chrome://extensions, enter the detail page, and you will see every requested permission; use the Network panel to watch for outbound requests. Firefox shows the same list on the "Permissions" tab of about:addons.

Which is safer, an online JSON tool or an extension?

The premises differ, so there is no absolute answer: an online tool's boundary is a single tab and it can be verified offline, while an extension's boundary depends on its permissions. A verified client-side online tool can be more controllable for sensitive data than a high-permission closed-source extension.

Can I keep using the extension from the incident?

You can, but that trust chain has already broken once: going closed-source and accepting a data partnership are accomplished facts. Besides the same author, there is an open-source successor (arnav-kr) and the classic open-source build (callumlocke); audit the manifest using this article's method before reinstalling.

Is an extension that only opens local JSON files automatically safe?

Its permission surface is indeed small (e.g., storage only), but still check for host permissions and content scripts — whether capability is minimized is determined by the manifest, not by the marketing copy.