Legal

Privacy Policy

Last updated: May 2026 · Version 1.1.4

What data Potatofy collects

Nothing, by default. The extension operates entirely on your device. It reads your browser's tab state, memory usage, and the URLs of pages you visit — but only locally, to decide which optimisations to apply. None of this is stored beyond the current session or transmitted anywhere.

Local storage only

Potatofy stores six things in chrome.storage.local on your device:

• settings — your feature toggle states and numeric thresholds (e.g. idle timeout, memory pressure level). No browsing history, no URLs, no page content.
• stats — estimated counts of blocked requests, discarded tabs, and similar aggregate numbers used to show you the popup's savings display. These are heuristic estimates, not a log of your activity.
• calibrationHistory — a rolling window (up to 100 entries) of median resource sizes observed by the PerformanceObserver on pages you visit, used to calibrate bandwidth-saved estimates. Contains byte sizes only — no URLs, no page content.
• calibratedBandwidth — the current aggregate median derived from calibrationHistory, used as a per-category bandwidth weight in the savings display.
• heapMeasurements — per-feature arrays of JS heap delta measurements (bytes freed) used to replace heuristic RAM estimates with real measured values. Contains byte counts and measurement timestamps (millisecond epoch integers) — no URLs, no page content, no personal data.
• privacyAccepted — a single boolean recording that you have accepted this privacy policy. Required before the popup activates.

This data never leaves your device unless you opt into sync (see below).

Session storage (clears on browser close)

Potatofy also uses chrome.storage.session for temporary operational state that is automatically erased when the browser closes. This includes: tab activity timestamps (used to determine idle time), active boost rules (host name and rule IDs for the current tab), in-progress stats counters (to survive service worker restarts within a session), accordion open/close state (UI preference), the device's RAM capacity (cached to avoid repeated API calls), and a poll-cursor timestamp used by the blocking-rule match counter to avoid re-processing already-counted rule events. None of this data persists across browser restarts.

Optional cloud sync (opt-in, off by default)

If you enable Sync settings to Google in the popup, Potatofy mirrors your feature toggle settings to chrome.storage.sync. This uses Chrome's built-in sync infrastructure, which routes through Google's servers under Google's privacy policy. Potatofy does not operate any server; we have no access to this data.

What is synced when enabled:

• Feature toggle booleans (e.g. whether blocking is on or off)
• Numeric thresholds (idle timeout minutes, memory pressure MB)

What is never synced unless you explicitly turn on a second toggle (Also sync site lists):

• Your whitelist (the domains where Potatofy is disabled)
• Per-site potato-mode settings (per-domain JS/image kill)

These describe your browsing habits and default to local-only.

To opt out: Toggle Sync settings to Google off in the popup. The extension immediately calls chrome.storage.sync.clear(), purging the synced copy from Google's servers. No data lingers.

No analytics or telemetry

Potatofy contains no analytics library, no crash reporter, no usage telemetry, and no remote logging of any kind. There is no server for us to send data to. You can verify this by reading the source: every network call in the extension is either a Chrome declarativeNetRequest rule (blocking outgoing requests) or a fetch(chrome.runtime.getURL(...)) call that reads a file bundled inside the extension itself.

No remote code

All code and rules ship inside the extension package. The blocking rule lists (rules/static-rules.json, rules/font-rules.json, rules/site-killers.json) are bundled at install time and only updated when you update the extension through the Chrome Web Store. No rules are fetched from the network at runtime.

Permissions and what they access

The extension requests several Chrome permissions. Here is exactly what each one reads or writes:

• tabs — reads tab URLs and active/audible/pinned state to decide which tabs to suspend. No page content is accessed.
• storage — reads and writes your settings and stats counters as described above.
• alarms — sets recurring timers for idle checks and stats flushes. No data is involved.
• contentSettings — writes per-site JavaScript and image blocking settings when you use "Kill JS here" or "Kill images here". Only the specific domain you request is affected.
• declarativeNetRequest — applies static and dynamic network blocking rules. No request content or URLs are read by the extension; the browser engine handles matching internally.
• declarativeNetRequestFeedback — polls getMatchedRules() once per minute to count how many rules fired. Only rule IDs and timestamps are returned — no request URLs, no page content.
• system.memory — reads the device's total and available RAM. The total capacity is cached in chrome.storage.session (cleared when the browser closes) to avoid repeated system calls; free RAM readings are transient and never stored.
• windows — iterates open browser windows to find the active tab in each window before discarding idle ones.
• host_permissions: <all_urls> — required for blocking rules to apply to any domain, and for the content script to run on every page to freeze background timers.

Children's privacy

Potatofy does not collect any personal information from anyone, including children. There is nothing to collect.

Changes to this policy

If we ever change how data is handled in a meaningful way, we will update this page and bump the version number at the top. The extension's GitHub repository tracks the full history of this document.

Contact

Questions or concerns? Open an issue on GitHub.

---

Potatofy is open source (GPLv3). You can read every line of code at github.com/Funnykid7/Potatofy-extension.