“WholeTake” Chrome Extension
Last updated: 2026-10-22
“WholeTake” (formerly “AI Web Summary & Translate”; the “Extension”) is maintained by an independent developer. It helps you summarize and translate web pages using a large language model (LLM) endpoint that you configure yourself.
We take your privacy seriously. This policy explains what data the Extension processes, how, and what your rights are.
In one precise line: This version ships exactly two AI paths — your own key (BYOK) straight to the endpoint you choose, or Chrome built-in AI running on your device; neither goes through a developer server, and there is no telemetry. On the BYOK path your content goes only to the AI endpoint you configure; with built-in AI, inference runs on your device; results are kept locally by default. Exactly what each feature sends, whether it is automatic, and how many model calls it makes are laid out in the data-flow matrix (DATA_FLOW.md).
This version ships exactly two AI paths: your own key (BYOK) straight to the endpoint you choose, or Chrome built-in AI running on your device. On both of them the developer collects no user data on any server (note, however, that your page content is sent to the AI endpoint YOU choose — that is the nature of BYOK, which is different from “sends no data anywhere”). The Extension:
Everything you enter on the Settings page is stored only in your Chrome browser’s storage:
The Extension’s own pages also use window.localStorage (not chrome.storage) for 11 display and
ask-panel preferences only — numbers, booleans, layout coordinates and your interface language (kgAskDeep decides whether a question reads all candidates in batches, i.e. how many model calls it makes — not layout; the candidate cap, batch size and batch limit are ordinary adjustable settings from v1.51 (defaults 48 / 8 / 6; 0 = unlimited, still hard-capped at 60 batches) — larger values mean more calls, billed by your own endpoint as always). They
contain no page content, no credentials and no personal data, are never synced and never leave
your device:
wt-theme (light/dark/auto theme, used to avoid a first-paint flash), kgAskPanelW /
kgAskFontPx (knowledge-graph ask panel width and font size), kgAskBox (where the answer window was dragged to and how big it is — four numbers), kgAskDeep (the ask panel’s “deep search” toggle, one boolean), kgLegendOpen / kgLegendBox
(legend collapsed state, window position and size), spFontPx (side panel font size),
wt-options-advanced (whether the settings page shows its advanced settings — one boolean),
wt-uilang (the interface language you chose and its text direction, again to avoid a
first-paint flash), and wt-uilang-pack (an offline copy of the Extension’s own interface
text file for that language — literally the _locales/<lang>/messages.json that ships inside the
Extension, cached so the first frame can already be in the right language; it contains none of
your data).
To clear them: use your browser’s “Clear browsing data -> Cookies and other site data”, or remove
the Extension.
Keyboard shortcuts are not in that list: since v1.39 the Extension has no in-page
shortcut handling of its own, and the browser-level shortcuts are managed by
Chrome’s own Keyboard shortcuts page (chrome://extensions/shortcuts) and stored
by Chrome, not by the Extension.
Where your API keys live is your choice:
Keys have three storage modes, chosen under Settings → Key Storage:
chrome.storage.local): API keys (the Bedrock API Key — including the per-slot ones of the three independent models — and any OpenAI-compatible keys) never leave this device and are not synced through your Google account.sessionCreds in chrome.storage.session, added in v1.37): keys are never written to disk and never synced, and are cleared automatically when the browser closes — you will need to re-enter them next time. Recommended for shared computers and high-sensitivity environments. Requires “Keep API keys only on this device” to be checked first.
A note so this is not oversold: this is not a password vault — while the browser is open, the Extension’s trusted contexts (background service worker, Settings page) still read it in order to call the AI endpoint you configured.chrome.storage.sync and sync across your signed-in Chrome devices (not additionally encrypted).chrome.storage.sync so they follow you across devices.In every one of this version’s key-storage modes, none of this is ever sent to a developer-operated server or any intermediary (only to the AI endpoint YOU configured, when the Extension calls it). We still recommend:
When you actively trigger “Summarize” or “Translate”, the Extension sends the following to the AI endpoint you configured yourself (when you right-click a web link and choose “Summarize / Translate link in new tab” or “Summarize / Translate link in background tab”, or point at a link and press the “hovered link” keyboard shortcut, the Extension first opens that link in a new tab — in the background, without switching to it, for the background items and the shortcut — waits for the page to load, and then does the same thing on that page — what is sent is that new tab’s content, exactly as if you had opened it yourself and pressed Summarize):
hidden/inert blocks before parsing — small amounts of text hidden by deeply nested stylesheet rules may still be included, so we do not claim it is strictly identical to “what is visible on screen”)origin+pathname: before sending, the Extension strips the query string (including access tokens / signed-URL parameters), the #fragment, and any userinfo credentials (see sanitizeUrlForModel in src/defaults.js); path segments that look like access tokens (an online document’s long ID, the code in a password-reset link) are replaced with “…”, and so are path segments that contain an email address (for example /users/alice@example.com/, including the %40 form) — purely numeric IDs (article or order numbers) and public @handles are kept; this covers the URL only, so an email address that appears in the page text is sent along with the page content; the path is capped at 120 characters. The full original URL is kept only on your device (history and cache matching) and is never sent out. The title and URL are placed inside the prompt’s data block, marked like page content as “data, not instructions”; if your custom prompt does not reference the URL, the URL is not sent.YYYY-MM-DD, no time of day and no time zone) so the model can place the article’s dates in time; if your custom prompt does not reference , the date is not sent (the default translation prompt does not reference it; translation has its own rule, "Today's date when a paragraph mentions a year", below). Only when your custom prompt (summary or translation) references is your device’s time zone name (for example Asia/Taipei) sent as well — a time zone name roughly reveals the region you are in. With Chrome built-in AI, all of this stays on your device like all other content.imgDescV1: the description text and a fingerprint of the image and model settings only — no image, no URL; at most 200 descriptions; never synced, never written to disk, gone when the browser closes), so that pressing “Regenerate”, or summarizing the same image again later in the same browser session, does not resend it — images that failed to be read are not cached and are sent again; if you cancel while images are being read, the descriptions already received are kept there. “Clear everything” and the viewer’s “Clear all” actively remove it and verify by reading back. Descriptions made for a tab in an Incognito window are never written to this cache: they are kept only for that tab, in memory, and are discarded when the tab is closed; (2) the first 200 characters of each description are stored as that image paragraph’s excerpt together with the summary in your local “Recent results” (same lifetime as the summary; included in export and backup; deleted together with the record). A summary served from earlier results (no regeneration) sends no images at all. When collecting page images, the Extension does not take images inside same-site ad frames and does not request 1×1 / 2×2 tracking beacons on your behalf; other small non-content images (under 32 px wide or tall, or under 10,000 px in area) are still downloaded to read their size but are never sent to the model. Image fetching first goes through the service worker without your cookies (credentials: 'omit'); only if the image host blocks that (hotlink protection / WAF) is it re-fetched once from the page context. Fetched images are converted to base64. Image URLs pass a safety check (blocking non-http(s), localhost, private and link-local IPs); this check is based on the literal hostname and cannot defend against DNS rebinding (a public domain maliciously resolving to an internal IP) — this is a known, accepted residual risk that cannot be fully fixed in this version’s architecture — a pure browser extension that sends content only to the endpoint you configure, with no intermediary server. Security-sensitive users can uncheck “Include page images and charts when summarizing” to disable all image fetching entirely.On both of this version’s paths — your own key (BYOK) and Chrome built-in AI — the developer has no access to this data and operates no intermediary server.
What happens with unencrypted (http://) endpoints (as of v1.44): your content only ever goes
to the endpoint you configured yourself, but sending it in the clear is a risk in its own right, so
the Extension checks twice — once when you save the setting, and again immediately before every
request it sends:
https:// — always allowed.localhost, 127.0.0.1, [::1]) — allowed: the traffic never leaves your
computer (the default Ollama / LM Studio setup).http://192.168.1.50:11434) — refused by default.
To use one you must explicitly opt in under “Settings → Model settings → Advanced (risk options)”,
because other devices on the same network can sniff plaintext traffic.http://ollama.local, http://nas:11434) — content
follows the rule above; but if that endpoint has an API key, it is refused outright and no
setting can allow it — such names carry no authentication, so any device on the same network
can claim the name and receive your key. Use the machine’s LAN IP address instead, or https://.http:// endpoint on the public internet — always refused, with or without a key, and
there is no setting that turns this off. (Before v1.44 an internal field allowed this case; it
has been removed entirely.)The technical criteria and where they are implemented are in the “endpoint transport policy” table in SECURITY.md.
Automatic calls beyond the summary itself (on by default, all to your same model endpoint, each can be turned off in Settings):
Topic pages, mind maps, and knowledge-base Q&A are manually triggered (see Section 3 below and DATA_FLOW.md). Exactly what each feature sends, whether it is automatic, and the estimated number of model calls are laid out in the data-flow matrix (DATA_FLOW.md).
Export diagnostics (CORE-1510-F4): Settings → About (next to “Feedback”) can export a diagnostics file to help us debug — the file is only downloaded to your device, never sent anywhere by itself; whether to hand it to the developer is your call. By default the file contains: end-of-task snapshots for the last ≤50 tasks (timestamps, cache decision, call count, error code, provider and model name, the endpoint’s masked label, whether the result was saved; field by field in the “Diagnostics ring” item below — including YouTube caption-source codes, PDF reader layout counts, the summary processing trace, link-task codes, per-round translation counters and knowledge-base citation-check counters, all fixed codes and numbers), the most recent translation outcomes (URL and host name reduced to hashes — for tabs in an Incognito window not even the hashes — plus the names of the translation and proofreading models used), queue and index state (counts and fixed codes only; for the index we only record whether an error occurred, not its text), the health of the “Recent results” store (whether the index format is valid and how many records it lists, number of index chunks, how many are missing and how many carry a time range, number of record shards and staging keys, whether an import is unfinished and in which mode, how many deletions are pending, whether a leftover copy of the old single-key index or a migration backup still exists, the running total and time of automatic removals, and the reason and time of the last rebuild of the index from the stored records — numbers, yes/no flags and fixed codes only, never a record id, title or URL), the running-task snapshot, the wipe generation, the extension version and Chrome major version, the built-in AI device status, your browser’s primary language code (for example “zh”; no region), the storage-protection status (ok / unsupported / failed / pending — whether extension scripts on web pages can read local storage; once the check has finished, anything other than ok means the Extension has stopped running on web pages; see SECURITY.md), how many Incognito items were left out of the file, and a non-sensitive subset of your settings — no URL, no page text and no key (allow-listed writer; any URL-like string is dropped whole, credential-shaped strings become ***; endpoints appear only as a masked label — cloud providers from the built-in preset list (OpenAI, OpenRouter, Gemini…) as their domain plus a short hash; custom, local and LAN endpoints only as a category (custom / local / lan), the port and a short hash. The host name or IP itself is never written; the short hash is mixed with a salt that is generated at random for each browser session and stays on your device (it is not in the file), so it can neither be reversed nor checked against a guessed address. So level 1 carries no URL, no path and no query string). Before the file is written, the whole file is scanned once more; any string that looks like a URL, an email address, an IP address or a key is replaced with [redacted], and the file records how many were replaced (normally zero). Only if you tick “include content” (the checkbox is shown after turning on “Show advanced settings”) will tasks started afterwards in a regular window also record the model’s raw output, the error text of tasks that failed, your most recent conversation contexts (including page text), the per-paragraph source and translation of the last 3 full-page translations (including the proofreading replies, the model, the batch and the attached instructions as fixed codes, and the AI-refinement terminology sheet), the full URLs of translation outcomes, and — for the last 5 summaries — the instruction shell that was sent (page text replaced by a hash code), the text of any automatic correction instructions (which may quote table rows and cited paragraphs from the page), the text description produced for each image, the excerpts of the paragraphs the summary cites, the carousel items that were marked as currently shown, and the full final summary. In an “include content” file, the keys you have configured (8 characters or longer) and strings that start like a well-known key (sk-, rk-, AKIA, ASIA, Bearer …) are replaced with ***; the model settings stored with those conversation contexts carry only the endpoint’s masked label (the same label as in the settings subset) — never the endpoint address, so a token in its query string (for example ?code= or ?sig=) or a user name and password written into it is not in the file; other text in the file — page text, model output and error messages — is kept as is, so a key in some other format that appears there would not be caught. Tasks in an Incognito window never record any of this content, even with the box ticked, and their conversation context and translation-outcome URLs are left out of the file. That file lives only in your Downloads folder; share it only with someone you trust; after the export the box unticks itself and the retained content is removed at once.
YouTube summaries: when you summarize on a YouTube video page, or use another feature that needs to read the video’s content there (such as mind maps; follow-up questions reuse what was already read and do not read from YouTube again), the Extension reads the video’s caption data from YouTube within that page (the primary path does not use your signed-in credentials; only if it fails, a fallback retries using your existing YouTube session within that page — all reads stay inside the YouTube page and nothing is ever sent to the developer); the caption text is then sent to the AI endpoint you configured (or processed fully on-device by the built-in AI). Summary material for a YouTube video is always obtained from YouTube within that page and never goes through the developer. When no usable captions can be obtained (the video has none, or they fail to load or are too short), the material becomes the video description (the information written by the uploader, together with the channel name and video length) plus top comments. A video without captions also counts as a failure of the primary path, so the fallback above first retries reading the captions using your YouTube session; the top comments are fetched from that page from YouTube (www.youtube.com) only when no usable captions can be obtained, with at most two additional requests per read, and the comment requests themselves do not use your signed-in credentials; at most 20 comments are taken (each up to 500 characters, at most 6,000 characters of comment text in total; the commenter’s display name and like count are added alongside) and sent together with the description to the AI endpoint you configured (or processed fully on-device by the built-in AI).
PDF summaries / translations (v1.49+): when you press Summarize or Translate on a PDF open in Chrome’s built-in viewer, the Extension opens its own reader page and downloads that PDF again from its source URL: the Extension’s background makes this one download, replaces the original tab with the reader page only once the first bytes confirm the URL still returns a PDF, and hands the downloaded file to the reader page (the reader does not ask the site a second time); if it clearly does not return a PDF, the original viewer is kept and a new tab asks you to drop the file in; if the server does not answer within 8 seconds, the original viewer is kept and the reader page opens in a new tab, which receives the same download when it arrives; if the server declares a file larger than 50 MB, no reader page is opened and the original tab shows a short notice — this step only prevents your copy of the PDF from disappearing, it is not an access control. The reader page downloads the file itself only if the browser shut down the Extension’s background before the reader received the file, or when you reload the reader page. Every download uses your existing browser login state (so PDFs behind a login wall work too) and goes to the PDF you are viewing — or, only when you press “Open in reader and summarize” (or “… and translate”) on the toolbar popup’s card about a link that did not open as a page, to that link’s address (the link you right-clicked or pointed at; it can be on another site, and nothing is fetched before you press the button); it never goes to the developer, and the downloaded file is held only in memory on your device, never written to the Extension’s storage. If the server redirects the request to a different site this time, the Extension does not read the redirected content for your safety and asks you to save the file from the viewer’s download button and drop it into the reader instead. The file is parsed on your device by a bundled copy of pdf.js; the extracted text layer (and, when “Include page images and charts when summarizing” is on: for documents with a text layer, the detected figures cropped as images — at most 4 per page and, by default, 20 per document (adjustable in settings to 10, 30 or 40), cropped on your device — are sent one at a time to the model you configured to get a short text description, exactly like web-page images, and each description is placed next to that figure’s caption before the summary is written; tables that can be reliably rebuilt from the text layer are read as text and are not sent as images; whole-page images inside such documents are described the same way; for scanned PDFs with no text layer, rendered images of whole pages are attached to the summary request — with Chrome built-in AI at most 4 of them, and the result says how many were read) is then treated exactly like web-page content: sent only to the AI endpoint you configured (or processed locally by Chrome built-in AI). Scanned PDFs with no text layer can only be summarized from page images — no OCR. Local file:// PDFs require that you enable “Allow access to file URLs” for this extension in chrome://extensions; otherwise you can drop the file onto the reader page manually. History and translation cache are keyed by the original PDF’s URL and title (same rules as section 3).
A PDF summary also carries a short “how much the model actually saw” statistic (text pages / scanned pages / figures detected and actually read / whole-page images / why figures were left out / how many reading segments there were and how many were left unread; numbers and reason codes only, no page text or images), stored locally with that history record. Very long PDFs (more than about 60,000 characters of text, counting an estimate of the figure descriptions) are read in segments by default: each segment (≤28,000 characters, including the descriptions of its figures; no images are attached) is one model call — up to two segments are read at the same time — and one final call merges them — at most 12 segments + 1; the “Read long PDFs in parts” setting turns it off, and Chrome built-in AI always makes a single call. What is sent is the same document’s text layer and figure descriptions, only split across several calls to your same endpoint — no new endpoint is involved. Detected tables are rebuilt as plain-text tables and sent with the text (no longer flattened into one line per cell). Before you press Summarize, the PDF reader shows an estimate — figures to be read one by one, tables read as text, how many figures will not be read when a document has more than the per-document limit, and the expected number of model calls — computed inside the Extension from counts only (no page text leaves your device for this). A “Text only this time” checkbox skips figure reading for that one summary without changing your settings.
Chrome built-in AI mode: if you choose “Chrome built-in AI” (Gemini Nano) in Settings, the model inference for the content above runs entirely on your computer and page content is not sent to any external AI endpoint. Note, however, that fetching source images, reading video content within the YouTube page (captions, plus top comments when no usable captions can be obtained), and the one-time download of the built-in model itself can still generate network requests (to image CDNs, to YouTube, and to the browser’s model-download service, respectively).
Where results are shown, and what the web page can see: the summary result, streaming output, and your follow-up input are carried, in side-panel mode, by an extension-owned page (extension origin); the on-page popup by default carries its content in an extension-owned iframe, so scripts on the page you’re browsing cannot read or alter the results or your input inside it — and the iframe handshake requires a one-time nonce obtained through the extension’s internal channel, which the host page cannot obtain or hijack. If the iframe is removed by the host page or fails to load for any reason, the default behavior is fail closed: the Extension closes the window and cancels the task — content is never handed back to the page automatically. In-page rendering happens only if you have explicitly opted in beforehand via the “Compatibility mode” consent setting; with that consent, a benign load failure (e.g. iframe load timeout) falls back to in-page rendering clearly labeled “Compatibility mode” — in that mode the content lives in the host page’s DOM and is readable by page scripts, so use side-panel mode for sensitive content. In compatibility mode only the current result is placed in the page: related summaries are neither looked up nor shown (no other page’s title, address or even a count is written into the host page) — although a result reused from the cache can be one saved for another page of the same site whose address this page declares as its own (see “What a web page may infer” in section 4); and if you have also allowed the Extension in Incognito, compatibility mode (in regular windows too) does not show the auto-tag row or the auto-tag call in the page — Incognito results have no tags, so leaving the row in would let the page tell that you are in an Incognito window (tags are still generated and saved; view and edit them in Recent results). Error messages written into the web page — the error card, the error area of the compatibility-mode window and the in-page mind map’s failure message — contain only a localized explanation and an error code, never the provider’s raw error text (which can include account IDs or internal host names). In side-panel mode, summary errors are shown in the side panel (the Extension’s own page) with the full text; translation errors are always shown on the web page. The full text of a failed task is also included in an “include content” diagnostics file (for tasks started after you tick it; not for tasks in Incognito windows). See SECURITY.md for the full trust-boundary description.
For review convenience and token savings, results are kept in your browser’s local chrome.storage.local:
seenAt: one timestamp updated when you open the same page again and the cache is hit, written at most once per day; local only, travels with backups, never sent — knowledge-base questions like “what did I read today” treat a record as in range when either its saved time or its last-viewed time falls in the period, so pages you re-read count too); for article pages where paragraph citations apply automatically, short excerpts of the cited source paragraphs are also kept so the viewer can show where each claim came from; for YouTube summaries, the citation time-range mapping (citeTimes) is also kept — stored locally only, used for jump-to-segment in the viewer; for full-page translation a lightweight record is also saved (page title, URL, and the number of translated paragraphs — the translated text itself lives only in the translation cache and on the original page, no full text is stored here), while selection translation saves the selected source text and its translation; disable “Keep a local Recent results history” to stop storing them. From v1.53 each entry also records a last-opened time usedAt: one timestamp updated when you actively open the entry from one of the Extension’s own pages into the Recent results viewer — for example from the list, related summaries, the knowledge graph, a topic page, a cited source in a knowledge-base answer, or the period list on the Reading stats page; reloading the viewer page, going back or forward to it, or Chrome restoring the tab at startup does not count. It is written at most once per day and never counted, stays local and travels with backups, and is used only to rank more recent or recently opened entries first when relevance is similar in knowledge-base answers, to keep them first when the full-text index reaches its size limit, to decide which entries are removed first when history exceeds 50,000 records, and for the “Opened again after saving” count on the Reading stats page (computed on the page together with seenAt, never stored separately); it is never updated from an Incognito window, and not written when “Keep a local Recent results history” is off. For a tab the Extension opened for a link, if the page redirects itself within 5 seconds after the action starts and the action is re-run, the record that the first run wrote for the page before the redirect is removed once the re-run’s result has been saved — but only when it is certain the page redirected itself (no click or key press in that tab since the new page loaded) and only if you have not touched the record (no questions asked, not cited by a topic page, tags and the knowledge-graph setting unchanged); other records for the same address are never removed. As of v1.20 this history is stored locally in an “index + per-record shard” layout, with the index itself split into fixed-size chunks (a purely internal storage-layout change; from v1.53 no read-only copy of the older single-key index is kept — any copy left by v1.52 is deleted the first time the updated Extension starts — and what is stored, its local-only nature, and your deletion/clearing controls are unchanged; the one-time migration backup expires automatically after 7 days, and deleting an individual entry also removes it from that backup, so “deleted means unrecoverable” is never undermined by the backup). “Recent results” has no size setting (it is limited only by your free disk space); beyond 50,000 records older ones are removed automatically — starting with those you haven’t opened in a long time, that aren’t in the knowledge graph and have no tags — and the viewer page tells you how many; you can also see current usage and delete old records manually in Settings. You can delete entries individually or clear everything in the viewer page. Topic tags are auto-generated by your configured AI endpoint by default (one extra tiny call after each summary; can be turned off in Settings; to reduce synonym tags, that call includes the names and confirmed aliases of your existing tags that literally overlap with the page) and are editable; tags also stay local only and power the Knowledge Graph page. Each entry can individually be excluded from the knowledge graph.kgRelations): this feature is suspended as of v1.16 (taken down for insufficient accuracy; the code flag REL_FEATURE=false hides its buttons and list in the UI; it will return after improvements). Existing data and handlers are retained but cannot be triggered. It was originally a manually triggered feature that sent tag text only (no page content) to your own endpoint; no such call happens today.topicPages): “Generate / update” and “Generate / update mind map” on a topic page are features you trigger manually — they send the saved summaries under that tag to your own configured AI endpoint to synthesize one wiki page or one multi-level mind map; the result is stored locally only (the wiki is editable), and the whole topic page (including its mind map) can be deleted. “Clear all local data (history + cache + knowledge base)” also deletes tag relations and topic pages.trc_* plus a small index trcLru used for eviction; the older single key translationCache from versions before v1.52 is deleted after an update — no longer merged in): translations of identical paragraphs (same model, same language, same version of the translation instructions and the same proofreading setting), one entry per paragraph, so re-reading a page costs nothing; up to about 2,000 paragraphs / 2.5 MB, oldest-saved evicted first.kbConceptStateV1 / kbConcept_* / kbConceptEvent_*): each tag’s stable identity, its name and former names, aliases with their confirmed/rejected status, your rename/merge decisions, the public knowledge-base mappings (Wikidata Q-numbers) you picked or pasted, and the one-sentence definition the model produced for the concept. Local only; deleted by “Clear all local data”; the viewer’s “Clear all” keeps only the parts still referenced by a topic page or decided by you.kbLex* / kbChunk_*): term → record number and term frequency, plus paragraph boundaries — no original text, rebuildable at any time; after you delete a record, the terms cut from it are physically removed by a background sweep (about 15 seconds later while the Extension’s background is running, otherwise the next time you use the Extension; sweeps are at least 10 minutes apart and deletions in between are folded into the next one); both “Clear knowledge-base data” and “Clear all” delete it.libraryId, used only to match up several backups of the same library; unrelated to your account or device; it stays inside the file), and a non-sensitive settings subset (custom prompts and display preferences) — it never contains any API key (the export uses a field allowlist, so credential fields structurally cannot enter the file). The whole operation is pure local file I/O — nothing is sent to any model or anywhere else. The export file contains your history summaries in plain text, so store it safely; on import you can choose “merge” (keep the newer version of each record) or “replace” (swap your whole knowledge base for the contents of the backup file). “Replace” does not wipe first and write afterwards. The imported records are written to a staging area and read back for verification first; only once everything is proven writable is the new index switched in by a single atomic write. Deleting the old data (records not present in the backup, topic pages, tag relations) happens strictly after that switch. So if any step fails before the switch, everything is rolled back and your existing knowledge base is left untouched; if the process is interrupted after the switch (for example by closing the browser), the new knowledge base is already usable and the remaining cleanup is completed automatically from a recovery journal on the next start. In the rare case where the switched-in index is also damaged at that point, the Extension rebuilds it from the stored records instead of deleting anything — for a “replace” import this means the records that were being replaced reappear in your list; running the same “replace” import again removes them. One thing to be clear about: once “replace” succeeds, records that are not in the backup file are deleted by design — that is what “replace” means, not a failure. Importing a backup never changes your settings or keys: the settings section of a backup file is not applied. Imported records are never reused as a cached summary: when you open the same page again, a new summary is generated. Timestamps in a backup (save time, Q&A time, last re-viewed and last-opened time) that are later than the moment of import are set to the moment of import.Non-persistent session context (chrome.storage.session): so that you can keep asking follow-ups after the Service Worker is recycled, the side panel can restore its view when reopened, and a few bookkeeping records survive a Service Worker restart, the Extension keeps eighteen keys in chrome.storage.session (a prefixed family such as conv_* counts as one). For every key we state what it holds, whether it contains a URL, when it disappears on its own, and whether “clear everything” removes it:
conv_*): the current tab’s follow-up context — the full extracted text of that page (up to 512 KB; only longer pages are truncated), the full summary, and every previous Q&A turn, plus a snapshot of the model settings (provider, model name and output options — not the endpoint address, which can carry a token in its query string) and one random document code (docNonce, as of v1.49; not a URL, no page content, never sent anywhere — it only lets the Extension still tell “has this tab moved to a different document?” after the Service Worker has been recycled, so that pressing Back clears the previous page’s context). As of v1.23 this snapshot always has every API-key field stripped out, and as of v1.53 the endpoint address as well (older snapshots written by earlier versions are sanitized in place on load) — the follow-up context snapshot never contains a key; follow-up calls re-resolve credentials from your current live settings instead. (Note: if you opt into the “keep keys only until the browser closes” mode described above, your keys are stored in a separate item, sessionCreds, in this same storage area — that is a storage location you chose deliberately, and is distinct from this conversation snapshot.) No URL. Removed on a real navigation (you move to a different page) or when you close the tab — reloading the same URL does not clear it (the page is loaded again, but the address has not changed, so the context stays), and a same-document History API change does not count (an infinite-scroll site rolling into the next article, a single-page app switching routes: the address changes but the document is the same one, so the context stays until a real navigation); “clear everything” and the viewer’s “Clear all” both actively remove it and verify by reading back. For medical, intranet, or otherwise sensitive pages, be aware that the full text of the page you just summarized stays here until a real navigation (you move to a different page), the tab is closed, or you clear — the kind of “page change” where only the address bar changes and the page is not reloaded does not remove it. It also keeps fingerprints (hashes, no text; at most 64 of each) of the Q&A turns that really happened in this tab — so that “save Q&A” can only save a real turn — and of the turns that have already been auto-tagged, so the same turn is never tagged — and paid for — twice. For a tab in an Incognito window the context is marked as such and is left out of diagnostic exports.panel_*): the already-rendered result messages in side-panel display mode, so the panel can replay after a reopen / SW restart; it also holds one view-state entry for that result (which round of suggested questions you dismissed with ✕, whether related summaries are collapsed, and whether you expanded the rest of them), so a replay or a revised summary does not bring back what you closed; and one entry with the text you typed into the side panel’s follow-up box but have not sent yet (up to 8,000 characters), so it is still there when you close and reopen the side panel — it is removed as soon as you send or clear it, and kept when the same tab gets a new result. When a long follow-up thread pushes the log over its limit, the oldest follow-up rounds are dropped first; the main summary, suggested questions, tags and the view state above are kept. No URL. Removed on a real navigation (you move to a different page) or when you close the tab (reloading the same URL does not clear it, and a same-document History API change does not count, as with conv_*); “clear everything” actively removes it and verifies by reading back.sessionCreds): present only if you chose that mode under Settings → Key Storage (see “Where your API keys live is your choice” above); never written to disk, never synced, cleared automatically when the browser closes, and removed when you switch storage mode or press “Clear keys”. No URL. This is a separate item from the conversation snapshot above. “Clear everything” deliberately leaves it alone — it is the key location you chose, and clearing data is not the same as signing out.bgActiveTasks): which kinds of task are running in which tab and when each one started — task kind plus a timestamp only; no page content and no URL. It exists so the toolbar popup can show queue state without waking the Service Worker, and so running tasks survive an unexpected Service Worker restart. It is maintained by the task lifecycle itself: with no task running it is an empty snapshot (the key is removed only after the Service Worker’s cold-start reconciliation); “clear everything” does not delete it separately — clearing first aborts every running task, so the snapshot becomes empty as a result.trrun_*): per-tab state that lets a “fill in the gaps” round know what the previous round already delivered. It holds content hashes, counters, short flags, and the URL of the page being translated — and zero characters of the page text, zero characters of the translation (the value that does hold translated text is deliberately not mirrored here). The URL is used only so the next round can confirm it is still looking at the same page; it is never sent anywhere. Removed on a real navigation (you move to a different page) or when the tab closes (reloading the same URL does not clear it, and a same-document History API change does not count, as with conv_*); it also carries a data epoch, so clearing the translation cache makes any leftover entry expire immediately; as of v1.46 “clear everything” actively removes it and verifies by reading back.bgLastRunOutcome): one record per tab, at most 20, describing how the most recent full-page translation ended — outcome kind, paragraph counts, per-class integer counters (diag, integers only — including the paragraph and call counts of the residue / date / currency / proofread checks, the number of terminology-sheet lines, how many reference-list paragraphs of a PDF were kept in the original language, and the collection duration in milliseconds with send / arrival timestamps — no page text), the names of the translation and proofreading models actually used in that run, a flag recording whether the page was replaced while the translation was still running plus its timestamp (docLost／docLostAt, a boolean and a number), a run id, the status/error card text, and, so that a late result can be re-delivered to the right page and never to a different one, the URL of the page that was being translated. That URL is kept solely for this identity check and is never sent anywhere. In a regular tab it is not removed when you navigate away or close the tab (that is precisely why it exists — after the page changes it still has to know whether to re-deliver); for a tab in an Incognito window the record is marked as such and deleted when that tab closes; otherwise it is only overwritten by the same tab’s next translation, or trimmed when there are more than 20 entries; as of v1.46 “clear everything” actively removes it and verifies by reading back (before v1.46 it did not, and the record stayed until the browser closed).topicDraft_*): while you are editing a topic page’s wiki text, the in-progress draft is kept per tag so that an accidental reload or a Service Worker restart does not lose what you typed. It holds the draft text you wrote plus two markers — the clear generation and a version code of the page’s saved text (its length and a hash, used to notice that another tab saved first) — nothing else, and no URL. It is removed as soon as the draft is saved or discarded; it deliberately survives reloads and navigation (that is its purpose); as of v1.46 “clear everything” removes it together with the topic page itself and verifies by reading back, so no orphaned draft is left behind; “clear knowledge-base data” removes it too. A topic page that is still open in edit mode at the moment you clear is shown a notice right away (“The knowledge base was just cleared or imported elsewhere; this edit will not be saved automatically — press Save to save the current content.”) and stops writing the draft back automatically (the text stays on your screen; pressing “Save” stores it as new content).bedrockClampV1): for the Bedrock provider, a table of “model ID → the output-token limit that model actually accepts”, so that after a Service Worker restart the same model does not hit the same limit error and waste a request. Model identifier strings and numbers only — no page content, no URL, no key. Gone when the browser session ends; “clear everything” does not delete it (it is not your data, it is a performance self-learning table).openaiClampV1): same as above, for OpenAI-compatible endpoints. Same contents, lifetime, and clearing behaviour as bedrockClampV1.bgTaskLedgerV1): snapshots taken when a task ends, for the last 50 tasks, so that “Export diagnostics” can hand us something useful when you report a problem: task id, kind, how it ended (including a cancellation reason code), a few timestamps (start / extraction done / collection start and end / first byte / the moment the page was replaced mid-task / end), how long it queued and whether it was admitted to start, the cache decision, whether the record was written back, whether the result was saved and, if not, a reason code (for example “Incognito window” or “sample article”), the local record id and document id of the result (internal identifiers, not URLs; a record id that is not in the Extension’s own format — for example one that came from an imported backup — is kept only as a short hash), provider and model name (if the model ID is an AWS ARN — e.g. a Bedrock application inference profile — the 12-digit account number is replaced by **** and your own resource ID by a salted short hash), the endpoint’s masked label (a preset cloud provider’s domain plus a short hash, or for custom, local and LAN endpoints only a category, the port and a short hash), error code (for example the category of a failed injection into, or extraction from, the page), integer counters, and the model-call ledger (number of calls, HTTP attempts, token totals — including the prompt-cache read / write token counts the provider reports), plus the calls and tokens spent afterwards on suggested questions and tags; for YouTube video pages, three fixed-vocabulary fields are also kept: the caption source kind (captions / video description / comments / none), which of two internal fetch paths was used, and a reason code when captions could not be obtained (e.g. rate-limited, no caption track) — never the video ID, URL or caption text; tasks on the PDF reader page also carry layout counts (numbers of paragraphs, formulas, tables and figures, how many pages got the second layout pass, and how many sentences were joined across a page break — integers only; no PDF text, URL or title) — for a public paper, this combination of counts may be enough to guess which document it was (for example 22 pages, 5 tables, 12 figures), so leave the file out if that matters to you; summary tasks also carry a processing trace: how many paragraphs and images were extracted, how many carousel items were marked as shown or off-screen, the names and lengths of the instruction clauses sent, the reason for each automatic correction and whether it was adopted (for the correction that rewrites leftover source-language words, also how many such words there were before and after — a count, never the words), for each page image considered (at most 20) the download result code and HTTP status, whether it came from the page’s own host, its format, a size class (under 16 KB / 64 KB / 256 KB / 1 MB, or larger), whether its caption looks like data, and the read result code, for a PDF how many figures were described, read as tables, captured as whole-page images or left out because of a limit, how many figures the summary cites, and, for Chrome built-in AI, which token-measuring interface was available and whether the page text had to be shortened again to fit, or the measurement could not be used (a fixed code) — fixed codes and numbers only (never an image, an image address or a caption), plus one yes/no flag in the extraction figures (whether only title-level metadata could be read); tasks started from a link you right-clicked or pointed at carry link-task codes (whether it ran in a background tab, which round it was, whether the page redirected itself and the task re-ran — and why that was decided, how long it queued, a coarse bucket of how long before that navigation you last clicked or pressed a key — never which key or where — and what happened to the first round’s record); translation tasks carry the integer counters of each translation round (how many paragraphs were collected, translated, left in the original, retried, failed and so on) and a fixed code for how that round ended, one entry per round, so a later “fill in the gaps” round does not overwrite the previous round’s numbers; knowledge-base Q&A tasks carry citation-check counters (how many cited sources were judged “numbers match”, “not compared” or “to double-check”, how often each reason occurred — for example a number that could be read two ways, a different currency, a range reduced to one end — and how many deep-search batches answered “nothing relevant” in another language; integers only; no question, answer, title or excerpt). Tasks in an Incognito window are recorded here too, with the same content-free fields and marked as not saved. No URL, no page text, no key — the writer only stores allow-listed fields and drops any string that looks like a URL. Gone when the browser session ends; both “clear everything” and the viewer’s “Clear all” actively remove it and verify by reading back.diagVerboseV1): exists only while you have ticked “include content” next to “Export diagnostics” in Settings (visible after turning on “Show advanced settings”); it means “for the tasks that follow, also keep the model’s raw output”. Cleared automatically after you export (the checkbox in Settings follows), removed by “clear everything” and the viewer’s “Clear all”, and gone when the browser closes.bgDiagVerbose_*): produced only while the flag above is on, for tasks started afterwards in a regular window (never for tasks in an Incognito window): the error text of a failed task (at most 2,000 characters); on the summary side the model’s raw output text (at most 64 KB per call), the text description produced for each image (at most 400 characters each, up to 20 images), the excerpts of the paragraphs the summary cites (at most 200 characters each, up to 40) and the carousel items marked as currently shown (at most 8 lines); on the translation side, per-segment source snippets, raw model replies (including the proofreading pass), cleaned translations, verdicts and cache decisions, the name of the model that handled each segment, its batch and which instructions were attached (fixed codes), and the AI-refinement terminology sheet (the model’s raw list and the lines actually used). The last 5 summaries and the last 3 full-page translations are kept. This is the only diagnostic data that contains page text and model replies — it exists only after you explicitly tick the box, is written to a file only when you press “Export diagnostics”, and is removed right after the export; if you never tick the box, not a single character of it is ever stored. “Clear everything” and the viewer’s “Clear all” remove it too.diagTagSalt): a random 32-character hexadecimal value, created once per browser session (only when first needed: when a finished task is written to the diagnostics ring, or when you press “Export diagnostics”), and mixed into every short hash in the diagnostics file (the endpoint’s masked label, record ids that are not in the Extension’s own format, and the host / path hashes of translation outcomes) — within one file the same endpoint still gets the same label, but a guessed address cannot be checked against it. No URL and no content; the value itself is never written into the diagnostics file and never sent anywhere; gone when the browser session ends; both “clear everything” and the viewer’s “Clear all” actively remove it and verify by reading back (a new one is created afterwards, so labels from before and after cannot be linked).imgDescV1): the text descriptions the model produced for page images and PDF figures, each stored under a fingerprint of the image and the model settings (no image, no URL; at most 200 descriptions and 300,000 characters in total), so that pressing “Regenerate”, or summarizing the same image again later in the same browser session, does not send the image again. Never written for tabs in an Incognito window (their descriptions are kept only for that tab, in memory, and are discarded when the tab is closed). Gone when the browser session ends; “clear everything” and the viewer’s “Clear all” actively remove it and verify by reading back.wipeGenV1): two integers (how many times data has been cleared, and when) — incremented by every “clear everything”, “clear knowledge-base data”, or backup import. It lets a topic-page editor that is still open at the moment you clear learn that “the data was cleared elsewhere”, so it stops writing your in-progress edit back automatically (the text stays on your screen; pressing “Save” stores it as new content). No content, no URL; gone when the browser session ends; “clear everything” does not delete it — it records the very fact that a clear happened.popupIntent:*): written only at the moment you press “Summarize” in the toolbar popup while “Show results in” is set to the side panel: a hand-off note holding a random identifier, the action name (summarize), the tab number, a 32-bit digest of that page’s URL (not the URL itself — the digest is used only to check “still the same page”), and the click’s timestamp. No page content, no URL, no key. Purpose: if the background happens to be asleep, the browser closes the popup at the same instant it opens the side panel, and the “start summarizing” message the popup sent can be dropped; when the background wakes up it uses this note to decide whether to start the summary. When the background decides (start, or don’t start because the note expired, the page changed or the tab was closed), the note is removed and a decision record is kept: only the same random identifier, the outcome (started / not started, with a reason code) and the note’s timestamp — no tab number, no URL digest, no content — so that a background restart cannot start the same click a second time. As long as the browser’s temporary storage accepts writes, one click starts at most once; if the browser shuts the background down after it decided to start but before the summary actually began, that click is not retried automatically and the side panel stays on “Summarize this page”. A note nobody takes over within 15 seconds, or whose tab was closed or moved to a different page, is removed the next time it is read and nothing is run; the decision record removes itself about 17 seconds after the click (or the next time it is read, if the background was shut down before then). “Clear everything” does not delete them separately (they exist for about 17 seconds at most).rdrTab_*): one entry per tab showing the Extension’s own PDF reader page: the URL and title of the PDF that tab currently shows (a local file you dropped in has no URL), plus a few numbers that contain no content — the page count, whether the PDF has a text layer, layout counts (integers only), and the number of the tab it was handed over from. Zero characters of the document text. Purpose: after the browser recycles the background, translating again on the reader page (for example filling in missing paragraphs) still knows which PDF it is, instead of retranslating the whole document. PDFs opened in an Incognito window are not handed to the reader page, so no such key exists for them; for reader tabs in normal windows the key records only the URL and title of the PDF that tab currently shows (plus the numbers above), and is removed when the tab closes or navigates to another page. Clear all removes these keys and verifies by reading back; a reader tab that is still open records its current PDF again the next time you use it there.linkDropV1): when a link you asked the Extension to open in a new tab (right-click “Summarize / Translate link in new tab” or “… in background tab”, or the hovered-link keyboard shortcut) disappears before it loads — typically because Chrome is set to download PDFs, or because the tab was closed — the Extension keeps, per source tab, the link’s URL, the action you chose (summarize or translate), and the time, so that the toolbar popup can offer “Open in reader”. Nothing is downloaded unless you press that button. Contains a URL. At most 20 entries; removed when you use or dismiss it, when the source tab closes, or 10 minutes after it was recorded; “clear everything” removes it too and verifies by reading back. Nothing is recorded for links opened from an Incognito window.Every key in chrome.storage.session is never synced, never written to disk, and never sent to the developer, and all of them are gone at the latest when the browser session ends. “A real navigation or closing the tab clears it” is true only for conv_*, panel_*, trrun_* and rdrTab_* — and, for tabs in an Incognito window, also for bgLastRunOutcome (a real navigation means you move to a different page; reloading the same URL does not count — the document is replaced, but these keys are deliberately kept so that a reload does not kill the tab’s running tasks, and reloading the PDF reader page keeps rdrTab_*; a same-document History API change — infinite scroll, a single-page app switching routes — does not count either, and these keys stay until a real navigation); bgLastRunOutcome of a regular tab and topicDraft_* stay by design until the next overwrite, a save/discard, or “clear everything”; imgDescV1 stays until “clear everything”, the viewer’s “Clear all”, or the end of the browser session; a linkDropV1 entry is removed when you use or dismiss it, when its source tab closes, or after 10 minutes; the three diagnostics keys bgTaskLedgerV1 / diagVerboseV1 / bgDiagVerbose_* stay until “clear everything” or a diagnostics export (the latter two are cleared right after export); sessionCreds, bgActiveTasks, the two learned tables, and wipeGenV1 follow their own lifecycles as described above; popupIntent:* exists for about 17 seconds at most (the hand-off note is removed when the background decides; the decision record removes itself on time, or the next time it is read).
Your controls:
conv_*) rather than passively waiting for the session to end.storage.session items “clear everything” deliberately leaves alone are your opted-in sessionCreds, the task snapshot bgActiveTasks, and the two learned output-limit tables (see the per-key list above); like everything else they are gone at the latest when the browser session ends.SEC-1520-7 / -14).On both of this version’s AI paths, all of this stays on your device only — never sent to a developer-operated server or intermediary. Exactly three things send any of it to the AI endpoint you chose (or to on-device Chrome built-in AI): auto-tags, which run automatically after each summary (the summary excerpt, up to ~4,000 characters; can be turned off in Settings); the standalone suggested-questions call, which also runs automatically and sends the same summary excerpt (up to ~4,000 characters) on selection summaries, when the question section of a full-page summary fails to parse, on Chrome built-in AI’s two-stage flow, and when a cache hit finds a record that has no questions yet (can be turned off in Settings; when a full-page summary goes to your own AI endpoint, the questions are produced inside the same single summary call and nothing extra is sent); and the content sent when you actively use topic pages / mind maps / knowledge Q&A (knowledge Q&A also includes today’s local date — no time of day or time zone — so that ranges such as “last month” can be resolved). There is one further optional path that does not go to an AI endpoint and is off by default (next section): once you turn on “Allow public knowledge-base lookup (Wikidata)”, only one concept name goes to Wikidata when you click “Find public mapping”, and only the new tag names of each summary included in the knowledge graph (at most 6) go to Wikidata when its tags are generated (untick “Automatically look up public mappings for new tags” to stop the latter).
Proofread once more after translating (v1.51; a sub-option of “AI refined translation”, on by default): with it on, some paragraphs (long paragraphs whose numbers cannot all be found in the draft translation — and, when the source is written in a less common script such as Sinhala, every long paragraph) have their source text and draft translation sent once more to the same model (or your primary model) to check for omissions — the proofreading pass may only add what was left out, translate words left in the source language, or restore a number from the source; a reply that rewrites wording the draft already has is discarded. Apart from the date described next, nothing new is sent, the same paragraph simply goes out a second time; paragraphs whose translation still carries source-language words, whose dates are ambiguous, or that replaced a currency named in the source with a different one, are likewise re-sent at most once each. The call caps and billing are in the translation row of DATA_FLOW.md.
Today’s date when a paragraph mentions a year (TRC-1520-11): when a paragraph mentions a year (a Gregorian year in any numeral system, or a Buddhist, Japanese-era or Minguo year), the translation and proofreading instructions also include today’s date from your device (the date only — no time or time zone; this sentence covers translation only — for the date sent when summarizing, and the time zone sent only when a custom prompt references it, see “2. Page content” above) so the model can tell past events from forecasts; paragraphs that mention no year get nothing extra. The exception is a custom translation prompt of your own: if it references or, every translation request carries today’s date or your device’s time zone name, whether or not the paragraph mentions a year (the default translation prompt references neither).
The Extension does not run in Incognito windows unless you turn on “Allow in Incognito” for it on chrome://extensions. If you do, a summary or translation of a page in an Incognito window is shown but not saved:
<link rel="canonical"> or og:url tag) is used only when it is on the same site as the page’s real address — the same host, or a site’s main address (with or without a leading www.) and its mobile or AMP address (one more leading m., mobile. or amp.), so a site’s mobile and AMP pages count as that same site (two mobile or AMP addresses are not matched with each other, and neither are addresses left with only a top-level domain such as .com once that prefix is removed). So from a reused summary a site can learn at most whether you summarized one of its own pages — and in compatibility mode that page’s saved result, together with what was saved with it (such as follow-up Q&A you saved), is then drawn into the page. One exception: on a shared domain where many people’s sites sit side by side (such as github.io) or under a multi-part domain ending (such as co.uk), the site named m, mobile or amp there counts as the same site as the shared domain itself and as the site named www there, so those few sites can also learn whether you summarized one of each other’s pages. Reuse of translations, image descriptions and downloaded images is keyed by content, not by address, so a page that includes paragraphs or images taken from another site may also learn whether you translated or summarized that content before. Some signs we have confirmed: (1) when every paragraph of a full-page translation is reused, the notice “Reused the previous translation …” appears and the paragraphs appear at once — from saved translations in a regular window, or, in either kind of window, when the same tab translates the same paragraphs again; (2) a compatibility-mode summary taken from a saved result has a “Regenerate” button and no elapsed time in its status line, which happens only in regular windows; (3) with the on-page popup or in compatibility mode, the progress card on the page closes without waiting for the model when a saved summary is reused, and its “Reading images (3/5)…” line starts from the number of image descriptions reused; (4) in a regular window, an image the Extension downloaded before may be served from the HTTP cache, so its server receives no new request, whereas from an Incognito window the Extension requests it again every time (for example when you press “Regenerate”). This is not a complete list.conv_*, side-panel replay log panel_*, translation round bookkeeping trrun_*), in chrome.storage.session — memory only, never written to disk — and it is removed when you close that tab. Besides that, the paragraphs an Incognito tab has just translated and the image descriptions it has just made are kept only in the Extension’s background memory (see “How reuse works” above) and are discarded when you close the tab (the paragraphs also when the tab moves to a different page). The last-translation-outcome record (bgLastRunOutcome) of an Incognito tab is marked as such and deleted when that tab closes. In addition, when “Show results in” is set to the side panel and you press “Summarize” in the toolbar popup of an Incognito window, the same hand-off note is written (popupIntent:*, see section 3 above): the tab number, a 32-bit digest of that page’s URL and the click’s timestamp — the digest is not salted, so someone holding a list of candidate URLs could compute each one and confirm which page it was; it is removed as soon as the background decides, and lives for about 17 seconds at most.bgTaskLedgerV1) still keeps one content-free snapshot per Incognito task (timestamps, counts and fixed codes, marked as not saved), so that a problem can still be reported.The concept editor on a topic page lets you attach a public knowledge-base mapping (a Wikidata Q-number) to a tag concept. You can paste a Q-number yourself (zero network traffic), or turn on an option that is off by default to look up candidates (the setup wizard’s last step, “Allow public knowledge-base lookups (Wikidata) to match concepts across languages”, and Settings → “Knowledge” are the same switch; both start unticked):
https://www.wikidata.org/w/api.php carrying that concept’s name — one string (in your interface language); while the sub-option “Automatically look up public mappings for new tags” is ticked (ticked by default; effective only while the option above is on), the same endpoint also receives each new tag name of a summary that is included in the knowledge graph (at most 6 per summary, one request per name; language = the tag’s language; for ambiguous names at most one extra wbgetentities call for type and sitelink count) while that summary’s tags are generated. Names already looked up are not re-sent for 30 days (7 days for misses); results and the “already looked up” record stay on this device (kbWdCacheV1, removed by Clear data). The manual button never reads this cache and contacts Wikidata every time you click. The name is read from the concept table by the background script; it is never the content of any input box on the page. Every request carries a self-identifying header, Api-User-Agent: WholeTake/<extension version> (<project URL>) — Wikimedia asks automated clients to identify themselves; it says which version of the extension sent the request and nothing about you (if your network strips that header, the same lookup is retried once without it). As with any network request, Wikidata’s servers also see your IP address and the ordinary headers your browser sends.kbWdCacheV1, removed by Clear data, never exported). A mapping is attached automatically only for a candidate whose label matches exactly in a matching language (several exact matches are narrowed by type / language / description / sitelink count, and nothing is attached if they still tie; without an exact label match only a single alias match is accepted), marked “Auto-mapped, pending” — on the topic page you can ✓ confirm or × reject it; mappings you already confirmed or rejected are never overwritten by an automatic result, and a rejected one is never revived by a later automatic lookup; otherwise nothing is stored; nothing is looked up while offline. This runs in the background, but only right after a summary you triggered — it never wakes up on its own; the manual “Find public mapping” button still contacts Wikidata only when pressed and does not read this cache.kbWdCacheV1 — never the candidate list); both live inside the local tag concept table and are cleared together with it. An automatic mapping also records the label Wikidata returned in your language as a “Wikidata proposed” alias (removable, not used for tag resolution); once you ✓ confirm a mapping, later foreign-language tags carrying the same Q-number are merged into that concept. Q-numbers produced by a model from memory are never accepted.The Extension sends the page content described above to the AI endpoint you specify. You are responsible for understanding and agreeing to that endpoint’s privacy policy. Common endpoints:
Some providers offer a free tier whose terms differ from their paid service — for example, content sent under the Gemini API’s unpaid tier may be used by Google to improve its products and may be read by human reviewers, and Google’s terms require you to be 18 or older. The Extension shows this notice when you pick Gemini in the setup wizard or in Settings; check your provider’s terms before sending sensitive or personal content.
The developer is not responsible for any third-party service’s data handling.
Model-list fetch from the Settings page (not a summary/translation request): when you open Settings, or leave a key / region / endpoint field after editing it, the Settings page sends one GET with that credential set to AWS Bedrock (https://bedrock.<region>.amazonaws.com/foundation-models) or to the OpenAI-compatible endpoint you entered (/models) to list the selectable models. The request carries only the credential and the request itself — never any page content; the main settings plus the three independent-model slots make at most four credential sets, each requested on its own, and only for the provider/endpoint that would actually be used at run time (e.g. zero requests when Chrome built-in AI is selected). “Test connection” likewise sends only a fixed string (see DATA_FLOW).
The Extension requests the following Chrome permissions, each used only for its core features:
| Permission | Purpose |
|---|---|
storage |
Stores the settings above, plus “Recent results” and the translation cache (local chrome.storage.local, never synced; “Recent results” has no size setting and is limited only by your free disk space — beyond 50,000 records older ones are removed automatically (starting with long-unopened records that aren’t in the knowledge graph and have no tags) and the viewer tells you so; delete entries or clear everything in the viewer, or delete old records manually in Settings — see section 3 above) |
scripting |
Injects the content script into the page to show results and translations; and two small self-contained functions — reading the address of the link under the pointer when you press the hovered-link shortcut, and a short navigation watcher in a tab the Extension opened for a link |
contextMenus |
Adds the right-click “Summarize / Translate selection” items (shown when text is selected) and, on http/https links, “Summarize / Translate link in new tab” and “… in background tab” (opens a new tab for that link — in the foreground or in the background, as the item says — and runs on that page once it has loaded); runs only when you click a menu item |
sidePanel |
Display mode (default since v1.28): summary results are shown in the browser side panel, only on tabs where you triggered a summary (per-tab content; the panel does not follow you to other tabs); you can switch back to the in-page dialog in Settings. The panel only renders results you explicitly requested; it reads nothing by itself |
unlimitedStorage |
Keeps the local “Recent results” history and knowledge base from being capped by the browser’s default local-storage quota (the Extension itself has no size setting — only a 50,000-record safety limit). The data still lives only on your device — never synced or uploaded |
host_permissions: <all_urls> |
Lets the Extension work on any site you’re reading, and lets the service worker fetch your configured AI endpoint and page-image CDNs (CORS bypass); since v1.49 it also lets the Extension download again the PDF you are viewing — or the PDF link you chose to open in the reader from the toolbar popup — from its source (the Extension’s background downloads it once and hands it to the reader — see “PDF summaries / translations” above); and it lets the Extension inject its content script into the new tab opened for a link you right-clicked or pointed at (that page is not the tab you were on when you clicked the menu or pressed the shortcut) |
declarativeNetRequestWithHostAccess |
Used ONLY to strip the Origin header from requests the Extension itself sends to your own configured local AI endpoint (loopback such as Ollama / LM Studio). Local servers reject the browser-added Origin: chrome-extension://<id> with a CORS 403; removing it lets your own local model accept the request. The rule is scoped by initiatorDomains to THIS extension’s initiator only (never any web page), covers loopback automatically and LAN only after you explicitly opt in, and NEVER public endpoints — one modifyHeaders(remove Origin) rule per configured local endpoint origin (typically one, at most four - deduplicated across the main/summarize/translate/knowledge endpoints), and nothing else: it does not block, redirect, read ordinary web-page traffic, or read/modify cookies |
The content script is injected on demand (since v1.37; zero resident scripts since v1.39): no code from this extension is resident on any web page — the manifest declares no content_scripts. The full script loads into the current tab only when you trigger a summary/translation (keyboard shortcut, context menu, or popup) — or, for a link you right-clicked or pointed at, into the new tab it opens; if the page swaps documents while that action is still running (for example you reload it), the same script is injected into the same tab once more so the action can finish or the side panel can re-attach to the page (no new task is started); and the first time compatibility mode shows a result inside the page, the Extension’s own bundled formatting library is injected into that same page. Content is extracted only when you explicitly trigger it, never read or uploaded without your explicit action. Two smaller injections exist. When you press the “hovered link” shortcut, a few lines of code run in every frame of the current tab only to read the address of the link under your mouse pointer (or the link that has keyboard focus) — no page content is read and nothing is stored. In a tab the Extension opened for a link, a small watcher runs from the moment the new page loads until 5 seconds after the action starts and reports only whether a navigation in that tab was started by the page itself or followed one of your clicks or key presses (a time difference — never which key or where you clicked), so that the action is re-run only when the page redirected itself.
chrome://extensions deletes all its settings dataThe Extension is not designed for children under 13 and does not knowingly collect children’s data.
Material changes will be reflected on this page with an updated “Last updated” date. Please check back periodically.
For any privacy questions:
The Extension’s source code is not currently public. If it is open-sourced later, a link will be added here for review. If you have questions about how privacy is implemented, email us — we’re happy to explain the technical details.