Privacy Policy for JaDict

Last updated: July 27, 2026 Effective version: JaDict 2.0.0

Summary

JaDict is a multilingual dictionary and translation browser extension with a Vietnamese interface. Most data stays on the user’s device.

When the user invokes an AI feature, JaDict sends the user-provided text to the AI provider the user has configured, using the user’s own API key. The request goes directly from the user’s browser to that provider, with no intermediary server. That is the default and it is what happens unless the user deliberately signs in to the optional JaDict account described below.

This policy distinguishes local storage from transmitted data. JaDict does not claim that browser extension storage is encrypted.

AI providers JaDict can transmit to

JaDict is provider-agnostic. The user chooses one provider and supplies a key for it. Text is transmitted only to the selected provider:

Provider	Endpoint	Policy
DeepSeek	https://api.deepseek.com/chat/completions	https://cdn.deepseek.com/policies/en-US/deepseek-privacy-policy.html
OpenRouter	https://openrouter.ai/api/v1/chat/completions	https://openrouter.ai/privacy
OpenAI	https://api.openai.com/v1/chat/completions	https://openai.com/policies/privacy-policy
Anthropic	https://api.anthropic.com/v1/messages	https://www.anthropic.com/legal/privacy

The chosen provider’s processing, retention, billing and security practices are governed by that provider’s own terms, not by this policy. Users should not submit confidential, regulated or personal information unless they understand and accept the policies of the provider they selected.

Data JaDict processes

User-selected and user-entered text

JaDict processes text when the user:

• selects text on a webpage and asks for a lookup;
• enters a word or passage in the toolbar popup;
• sends a chat message;
• asks JaDict to translate or explain content.

In the default trigger, selecting text alone transmits nothing. A small button appears beside the selection, and no request is made until it is clicked. The user may switch to a mode that looks up on selection, or to a mode that acts only on a keyboard shortcut or the right-click menu.

Surrounding sentence context

A single word is often ambiguous without the sentence around it. When the user requests a lookup, JaDict may include the sentence containing the selection so the result is correct for that usage. This is bounded to the surrounding sentence and is sent only as part of a lookup the user asked for.

Chat context

For contextual chat, JaDict may send up to the latest 20 locally stored user and assistant messages for the current tab, and only when the user sends a new chat message.

Text in form fields

A selection inside an input or textarea is readable in the same way as a selection on the page, because messaging apps put their composer in one. JaDict never reads a field whose type is password.

API keys

The user’s provider API key is:

• stored in browser extension local storage under providerKeys, keyed by provider ID;
• used in the authorization header of requests to that provider only;
• never intentionally written to source code, logs, URLs, fixtures, error messages or JaDict documentation;
• removable through JaDict’s clear-data control or by uninstalling.

Keys stored by JaDict 1.x under deepseekApiKey are read once for migration and are never written back.

Data stored locally

JaDict uses browser extension local storage and IndexedDB. Most data in this section stays on the device. If you explicitly accept the account disclosure and sign in, the allow-listed settings and history described under “The optional JaDict account” are also copied to your account so they survive reinstalling the extension or changing devices.

Browser local storage may contain:

• providerKeys, activeProvider and providerModels;
• extension enabled state, light/dark theme and the disable-AI setting (offlineMode);
• native language, pinned study languages and the active study language;
• per-site language memory (siteLanguages), which stores hostnames the user has explicitly pinned a language for;
• how lookup is triggered, and the delay before the lookup button appears;
• whether you accepted the disclosure for the optional paid account, recorded as the version of the wording you saw and when you accepted it (accountConsent). Storing the version is deliberate: a bare yes cannot answer what you agreed to, and a change to the wording should not inherit an old acceptance;
• if, and only if, you sign in to a JaDict account: which route lookups take (transportMode), your sign-in token (deviceToken), the email address you signed in with (accountEmail) and a cached copy of your credit balance (accountBalance). Signing out erases all four;
• account-sync state (accountSyncMeta) and a content-free history change signal (historySyncPulse). The state contains the account owner, last revision, last sync time, bounded deleted-entry ids, the most recent clear time, last error and whether a server deletion still needs to be retried. The change signal contains no query or generated response;
• AI acknowledgement state and first-run completion state;
• blocked site hostnames;
• synonym and antonym display limits;
• recent search entries;
• temporary search-popup transfer data;
• per-tab chat context.

IndexedDB stores lookup and chat history, which may contain:

• the user’s query or chat message;
• the generated response;
• timestamp and entry type;
• tab identifier and non-sensitive display metadata.

JaDict does not store page URLs in history. When the history database upgrades to version 2, previously stored url fields are removed. The local copy remains a working cache after account sync is enabled, so JaDict can open quickly and continue to show existing data when the network is unavailable.

Data sent to the selected provider

When the user initiates an AI operation, JaDict sends:

• the selected or entered text;
• the surrounding sentence, where it is needed to disambiguate;
• the instruction needed for translation, dictionary analysis, structured output or chat;
• recent chat context when applicable;
• the detected source language and the target language;
• the selected model ID;
• the user’s API key in the authorization header.

The optional JaDict account

JaDict includes an optional account for people who would rather pay per lookup than obtain a provider API key. It is off by default, it is never required, and bring-your-own-key remains available without a JaDict account.

Nothing described in this section happens unless you sign in. Before the sign-in field is shown at all, JaDict presents a consent screen in Settings that states what would be collected, and records which version of that wording you accepted. Without that acceptance, no email field is displayed.

If you do sign in, JaDict collects:

• your email address, used to sign in and to notify you about transactions. No name, phone number or location is collected;
• a sign-in token for this device, which you can revoke by signing out;
• the settings needed to restore JaDict on another device: theme, blocked site hostnames, synonym and antonym limits, the disable-AI setting, native and study languages, active study language, per-site language choices, lookup trigger and launcher delay;
• up to 500 lookup and chat history entries: entry id, lookup or chat text, generated response, timestamp, entry type and the display metadata needed to render or resume the entry. Page URLs, tab identifiers, derived search text, API keys, provider credentials and device tokens are excluded from the sync payload.

While you are signed in and have chosen to use the account for lookups, the text you look up is sent to the JaDict server, which forwards it to the AI provider using JaDict’s own key and deducts credits. The server does not retain a separate AI request log. If account sync is enabled, the lookup or chat may subsequently be retained as part of your encrypted history, as described above. Turning the account off in Settings returns lookups to your own key immediately.

Account sync, encryption and backups

Account sync is part of the versioned consent shown before the email field appears. An acceptance recorded for older wording does not enable this newer collection.

The browser sends changes automatically after settings or history change. The server merges history from different devices by entry id instead of replacing one device with another. A deleted entry is kept as a bounded deletion marker, and clearing history records the clear time, so an older device cannot silently restore data you deleted.

The current sync payload and every backup are encrypted at rest with AES-256-GCM. The encryption key is stored separately from the database, so a database dump by itself cannot read the payload. Transmission uses HTTPS.

Every accepted change keeps the version it replaced before the new current version is stored. JaDict retains at most 10 previous versions per account. Restoring an old version creates a new current version and preserves the version it replaced, so a restore can itself be undone.

If you withdraw account consent in Settings, JaDict requests deletion of the current sync payload and all of its backups. If the request fails because the service is unavailable, the device records the pending deletion and retries it while the sign-in token remains available. Signing out alone revokes the token on that device but does not delete the account, wallet, email address or payment records. Full account closure is not yet self-service; it will not be offered until a private support channel, a verified closure process and rules for legally required transaction-record retention are published.

Payment is by Vietnamese bank transfer through SePay. JaDict never receives or sees card numbers. What JaDict stores about a payment is the order code, the amount and whether it was paid.

Do not post an account email, bank information or transaction code on the public issue tracker.

Data JaDict does not collect

JaDict operates no analytics, advertising or telemetry. Unless you have signed in to a JaDict account, no data of any kind reaches a JaDict-controlled server.

JaDict never collects, with or without an account:

• payment card information;
• precise location;
• full browsing history;
• page screenshots, images or video;
• background keystrokes or mouse tracking;
• API keys, provider credentials or separate AI request logs.

Without an account, JaDict additionally does not collect names, email addresses or account profiles.

The content script runs on allowed webpages to detect a text selection. JaDict does not send full page content anywhere. Only what the user selects or types is transmitted.

Browser permissions

storage

Settings, provider configuration, recent searches, chat context and local history.

clipboardWrite

Used only when the user activates a copy control.

tabs

Identifies the current tab for chat context and opens extension pages. The active page URL is not stored in history.

contextMenus

Adds the right-click lookup entry.

<all_urls>

Allows the lookup popup to work on the pages the user visits. It is required because a translation tool cannot know in advance which page the user will read. JaDict can be disabled globally or blocked per hostname, and a blocked hostname never produces a request.

Security

• AI-generated HTML is rendered through allow-list sanitizers with escaped interpolation, into a closed shadow root.
• API keys never appear in URLs or runtime logs, and error messages never echo an upstream message that could contain one.
• All provider requests use HTTPS.
• Extension storage is sandboxed by the browser, but JaDict does not guarantee encryption at rest.
• Users are responsible for protecting and revoking their own provider API key if it is exposed.

User controls and deletion

Users can:

• choose a trigger where nothing is sent until a button is clicked;
• disable AI requests entirely;
• change or replace the provider and API key;
• block JaDict on specific hostnames;
• clear the per-site language memory;
• clear recent searches and chat history;
• export history as JSON;
• use the clear-all-data control to remove browser local storage and JaDict IndexedDB history;
• uninstall the extension to remove extension-managed local data.

Limited Use disclosure

JaDict’s use of information received from browser APIs adheres to the Chrome Web Store User Data Policy, including the Limited Use requirements. Specifically:

• data is used only to provide the user-facing dictionary and translation features described in the store listing and visible in the interface;
• with a personal API key, data is transferred only to the AI provider the user selected, and only to fulfil a lookup the user requested;
• with a JaDict account, requested lookup data passes through the JaDict server to the enabled AI provider, and the allow-listed settings and history described above are stored only after the versioned account consent is accepted;
• data is never used or transferred for advertising, ad targeting, profiling or creditworthiness;
• data is never sold;
• no human reads lookup or chat content as part of operating the service.

Service status and planned changes

The JaDict account server is deployed. The production email sender and server-side AI provider credential are configured and have passed delivery, authentication and minimal model-call checks. The payment webhook is configured and the explicit launch flag is enabled in production for end-to-end browser testing. There is no test-account allow list, so any signed-in account can currently create a transfer order. Public promotion remains blocked until a real transfer is verified, an identifiable seller and private support channel are published, refund and account-closure operations exist, and tax setup is complete. The extension asks the server rather than assuming those services are available, and does not show an email field before the account disclosure is accepted.

Screenshot text recognition and full-page translation are planned for later versions. Both would send more than the current selection, so both will be described here before they ship.

Seller identity

JaDict is published by the JaDict developer, not by Google or Mozilla. When paid credits are enabled, the legally identified seller will be named in the terms and the checkout screen before any order can be created. Terms of sale and refund terms are published at https://github.com/huuunleashed/JaDict/blob/main/docs/TERMS_OF_SALE_VI.md and are linked from the consent screen in Settings.

Contact

Public technical issues only: https://github.com/huuunleashed/JaDict/issues Do not post account, payment or banking information there. A private privacy and transaction-support address must be published before paid accounts are opened.