Is Mixmax: Email Tracking, Follow-Ups and Meeting Scheduling for Gmail safe?

Medium risk

Mixmax is medium risk. Mixmax requested selector/watcher JSON from extension.mixmax.com seconds after loading Gmail. The same loader runs on Gmail, Salesforce, LinkedIn: it fetches two config files into page globals, then loads the module watching page elements.…

Mixmax, Inc.v6.70.0Extension ID ocpljaamllnldhepankaeljmeeeghnidChrome Web Store
47Risk
Who publishes it

Mixmax - no other listings under this identity, 1 shared hostname

Publisher
Mixmax, Inc.
Declared legal entity
Mixmax
Registered address
548 Market St PMB 60764, San Francisco, CA 94104-5401, US
Registered contact
Mixmax, Inc.

Shared hosts - 1 hostname

Hostnames hardcoded in this extension that few other listings call. That can mean one operator behind both, and it can equally mean a small shared vendor, so it is context rather than a conclusion. Hosts that many listings call are left out: they are services, not connections.

mixmax.com
Also called by 1 other listing: Email Tracking for Gmail and Mass Emailing
AI-assisted analysis.

Mixmax findings

Mixmax loads remote page rules on Gmail pages

HighunwantedCWE-829Dynamic sandbox

Mixmax requested selector/watcher JSON from extension.mixmax.com seconds after loading Gmail.

What actually happens

You did this

You open Gmail, Salesforce, or the LinkedIn sales widget while Mixmax is installed.

The content script maps the page to a build target such as gmail-inbox, salesforce, or linkedin.

The extension did this

The extension requests remote selector and watcher rules for that page.

On Gmail, dynamic analysis observed the watcher and selector JSON files load from extension.mixmax.com within seven seconds.

Captured request

GEThttps://extension.mixmax.com/config/gmail-inbox-watcher.json

200 OK, 10,736-byte JSON response observed during dynamic analysis.

Captured request

GEThttps://extension.mixmax.com/config/gmail-inbox-selectors.json

200 OK, 25,504-byte JSON response observed during dynamic analysis.

Concrete configuration fields used by the Gmail page module

  • Page target
    gmail-inbox

    Tells the extension which web app you are using so it can load a matching rule set.

  • Compose body selector
    COMPOSE_DIALOG_BODY = .Am.Al.editable.LW-avf

    Points the extension at the editable email body area in your Gmail compose window.

  • Message watcher tag
    tag = onceOpenMessage; sources = message, expandedMessage

    Names a page element state the extension should detect while you read messages.

  • Watch condition
    attributeFilter = class; condition = has class h7

    Tells the extension which page changes should make a watched element count as active.

  • Finder interval
    nativeComposeStandalone finder retries every 5000 ms

    Controls how often the extension retries looking for selected Gmail elements.

The code that does this

Content script builds the Mixmax config URLs and stores both responses on window

Readable version

Readable loader excerpt showing the same config fetches and dynamic import

core/content/app.js
const SFDC_DOMAIN = /(^|\.)(?:sales)?force\.com$/;const hostname = window.location.hostname;const isGmail = hostname === "mail.google.com";const isLinkedIn = hostname === "www.linkedin.com" && window.location.pathname.startsWith("/sales/widget");let buildTarget;if (isGmail) {    buildTarget = "gmail-inbox";} else if (SFDC_DOMAIN.test(hostname)) {    buildTarget = "salesforce";} else if (isLinkedIn) {    buildTarget = "linkedin";}const LOAD_FAILURE_WARN_ORIGINS = [ "https://mail.google.com" ];function isValidWarningOrigin(origin) {    if (!origin.startsWith("https://")) return false;    if (LOAD_FAILURE_WARN_ORIGINS.includes(origin)) return true;    return SFDC_DOMAIN.test(origin);}const warnEnvironments = new Set([ "staging" ]);const rValidEnvironment = /^[0-9a-z-]+$/i;function getExtensionOrigin(environment) {    if (warnEnvironments.has(environment)) {        console.warn(`Mixmax extension is running from ${environment}.`);    }    if (!environment || environment === "production") {        return "https://extension.mixmax.com";    }    if (!rValidEnvironment.test(environment)) {        throw new Error("extension origin not valid");    }    if (Environment.previewBranch) {        return `https://extension-staging.mixmax.com/preview/${Environment.previewBranch}`;    }    return `https://extension-${environment}.mixmax.com`;}const GET_EVERYTHING = null;chrome.storage.local.get(GET_EVERYTHING, (function(storage) {    const environment = storage.environment;    const remoteSource = getExtensionOrigin(environment) + "/src";    const remoteConfig = getExtensionOrigin(environment) + "/config";    const version = storage[`loadableCodeVersion_${environment}`] || "latest";    const extensionBaseUrl = chrome.runtime.getURL(`loadable/${version}`);    void loadLocal(extensionBaseUrl, remoteSource, remoteConfig);}));async function loadLocal(scriptBaseUrl, cssBaseUrl, configBaseUrl) {    try {        await Promise.all([ loadCSS(cssBaseUrl, 6), loadConfigs(configBaseUrl, 6) ]);        if (isGmail) {            await gmailPageInteropLoad;        }        const sourceSubdir = null;        await loadScript(scriptBaseUrl, sourceSubdir);    } catch (err) {        if (isValidWarningOrigin(window.location.origin)) {            alert("Failed to load extension locally. Check Chrome DevTools console for errors.");        }        throw err;    }}async function loadScript(origin, sourceSubdir, numRetries = 0) {    const maybeSourceSubdir = validateSourceSubdir(sourceSubdir) ? `${sourceSubdir}/` : "";    const jsURL = new URL(`${origin}/${maybeSourceSubdir}build-${buildTarget}.js`);    await retry((async num => {        const url = new URL(jsURL);        if (num) {            url.searchParams.set("v", `mixmax-extension-${num}`);        }        try {            await import(url.href);        } catch (err) {            if (err && err[Symbol.for("mixmaxErrorSource")] === "mixmax-extension-source") {                err.isPermanent = true;            }            throw err;        }    }), numRetries + 1);}async function fetchJSON(url) {    const res = await fetch(url, {        mode: "cors",        credentials: "omit",        redirect: "follow",        referrerPolicy: "origin"    });    if (!res.ok) {        throw new Error(`failed to fetch JSON from ${url}`);    }    return await res.json();}async function loadConfigs(origin, numRetries = 0) {    [window.SELECTORS, window.WATCHER_CONFIG] = await Promise.all([ retry((async () => await fetchJSON(`${origin}/${buildTarget}-selectors.json`)), numRetries + 1), retry((async () => await fetchJSON(`${origin}/${buildTarget}-watcher.json`)), numRetries + 1) ]);}

The code that does this

The Gmail module consumes the remote watcher object when it is present

Readable version

Readable watcher replacement path in the Gmail module

loadable/latest/build-gmail-inbox.js
if (window.WATCHER_CONFIG) {  e.tags = {}, e.watchers = [], e.finders = {};  for (const [t, n] of Object.entries(window.WATCHER_CONFIG)) {    const r = Ts(n, t);    Object.assign(e.tags, r.tags), e.watchers.push(...r.watchers), Object.assign(e.finders, r.finders)  }  window.WATCHER_CONFIG = {}}

The code that does this

Background service worker polls runtime configuration once per minute

Readable version

Readable runtime configuration polling in the background worker

background.js
async function checkRuntimeConfiguration() {    if (!navigator.onLine)        return;    // Cache bust the gate URL just in case the browser decides to cache.    const url = Environment.getExtensionUrl() + '/extension-runtime-config.json?cb=' + Date.now();    try {        const response = await fetch(url, { cache: 'no-cache' });        if (!response.ok) {            error_captureMessage('Non-200 response from S3', {                culprit: 'Querying the extension runtime configuration',                extra: {                    status: response.status,                    body: await response.text().catch((conversionError) => conversionError.message),                },            });            return;        }        const runtimeConfiguration = await response.json();        const runtimeConfigurationKey = `runtimeConfiguration_${Environment.get()}`;        // TODO: use promise API as soon as we're on Mv3        chrome.storage.local.get(runtimeConfigurationKey, (storage) => {            // The API docs for `chrome.storage.local.get` say `storage` should never be null,            // but we've found it sometimes (though rarely) is.            if (!lodash_default().isEqual(runtimeConfiguration, storage === null || storage === void 0 ? void 0 : storage[runtimeConfigurationKey])) {                void setStorage({ [runtimeConfigurationKey]: runtimeConfiguration });            }        });    }    catch (errorThrown) {        errorThrown.sentryExtra = { fetchUrl: url };        error_captureException(errorThrown, {            culprit: 'Querying the extension runtime configuration',        });    }}chrome.alarms.onAlarm.addListener((alarm) => {    if (alarm.name === ALARM_NAME) {        void checkRuntimeConfiguration();    }});void chrome.alarms.create(ALARM_NAME, { periodInMinutes: 1 });

Error reports send user context to Datadog

MediumunwantedCWE-200Dynamic sandbox

We observed Mixmax send Sentry error reports to Datadog after Gmail activated it.

What actually happens

You did this

You open Gmail while the Mixmax extension is active.

The extension did this

The extension posts Sentry error-reporting envelopes to Datadog that can include your account URL, extension metadata, stack traces, and request history.

Captured request

POSThttps://sentry-intake.datadoghq.com/api/1/envelope/?sentry_key=pub684b6e57211adb32dfdcf62550795cc0&sentry_version=7

Seventeen POST requests were observed. The recorded error-reporting evidence says one event contained <test-account-email> in breadcrumb URLs, extensionVersion and extensionChannel tags, service tags, full stack traces, and API request breadcrumb history.

Observed fields and context in the error-reporting evidence

  • Gmail address in URL
    https://app.mixmax.com/api/loginToken?user=<test-account-email>

    A breadcrumb URL can identify your account when the email address is embedded in the request path or query string.

  • Extension version and channel
    extensionVersion=6.50.1, extensionChannel=main

    The report identifies which extension build and release channel produced the event.

  • Stack trace and culprit tag
    culprit=Setting cookies for iframes

    The report can include details about what code path failed and where the extension grouped the error.

  • API request breadcrumbs
    https://app.mixmax.com/api/loginToken?user=<test-account-email>

    Request history around the error can reveal what Mixmax API endpoints your browser contacted.

The code that does this

Sentry setup, scope enrichment, and user email context

Readable version

Background Sentry initialization

background.js
function configureSentry(environment) {    init({        dsn: 'https://pub684b6e57211adb32dfdcf62550795cc0@sentry-intake.datadoghq.com/1',        release: chrome.runtime.getManifest().version,        environment,        integrations: [new ExtraErrorData({ depth: 3 })],        async beforeSend(event, { originalException }) {            // If exception is present, check that it's the one that we want to log.            // E.g. we don't want to log network errors in case user has no internet.            if (originalException) {                const shouldLogError = await getShouldLogError(originalException);                if (!shouldLogError) {                    return null;                }            }            return event;        },    });    setTags({        extensionVersion: chrome.runtime.getManifest().version,        extensionChannel: Environment.getExtensionChannel(),        // We need to send service name as a tag to Datadog since error tracking group errors by the 'service' tag        service: DD_ERROR_TRACKING_SERVICE,    });}chrome.storage.local.onChanged.addListener((changes) => {    var _a;    if ((_a = changes.environment) === null || _a === void 0 ? void 0 : _a.newValue)        configureSentry(changes.environment.newValue);});setTimeout(() => configureSentry(Environment.get()), 0);

Scope enrichment and capture wrapper

background.js
function error_configureScope(scope, { user, tags, extra, fingerprint, culprit } = {}) {    if (user)        scope.setUser(user);    if (tags)        scope.setTags(tags);    if (extra)        scope.setExtras(extra);    if (fingerprint)        scope.setFingerprint(fingerprint);    if (culprit) {        scope.setTag('culprit', culprit);        if (!fingerprint) {            // See https://docs.sentry.io/platforms/node/data-management/event-grouping/sdk-fingerprinting/            scope.setFingerprint(['{{ default }}', culprit]);        }    }}/** * Wrapper for Sentry's captureException. */const error_captureException = function (error, options) {    // Log to console locally and log to Sentry for production.    if (!useRealClient()) {        console.error(error.stack || error, options);    }    else {        withScope((scope) => {            error_configureScope(scope, options);            captureException(error);        });    }};

A background error path passes user email into the report scope

background.js
ExtensionMessageBus.on('setCookiesForIFrames', async ({ user, origin }, _sender, sendResponse) => {    try {        const response = await fetch(`${Environment.getAppUrl()}/api/loginToken?user=${user}`);        if (!response.ok) {            error_captureMessage('Error getting login token', {                culprit: 'Setting cookies for iframes',                extra: { status: response.status },            });            if (sendResponse)                sendResponse(false);            return;        }        const loginToken = await response.json();        if (!loginToken) {            if (sendResponse)                sendResponse(false);            return;        }        chrome.cookies.set({            domain: 'mixmax.com',            expirationDate: Date.now() + 2 * 365 * 24 * 60 * 60,            httpOnly: true,            name: `mixmax_login_token_${user}_${Environment.get()}`,            partitionKey: { topLevelSite: origin },            path: '/',            sameSite: 'no_restriction',            secure: true,            url: 'https://mixmax.com/',            value: loginToken,        }, () => {            if (sendResponse)                sendResponse(true);        });    }    catch (err) {        error_captureException(err, {            user: { email: user },            culprit: 'Setting cookies for iframes',        });        if (sendResponse)            sendResponse(false);    }});

Content script Sentry initialization

core/content/app.js
function configureSentry(environment) {    init({        dsn: "https://pub684b6e57211adb32dfdcf62550795cc0@sentry-intake.datadoghq.com/1",        release: chrome.runtime.getManifest().version,        environment,        integrations: [ new ExtraErrorData({            depth: 3        }) ],        async beforeSend(event, {originalException}) {            if (originalException) {                const shouldLogError = await getShouldLogError(originalException);                if (!shouldLogError) {                    return null;                }            }            return event;        }    });    setTags({        extensionVersion: chrome.runtime.getManifest().version,        extensionChannel: Environment.getExtensionChannel(),        service: DD_ERROR_TRACKING_SERVICE    });}chrome.storage.local.onChanged.addListener((changes => {    var _a;    if ((_a = changes.environment) === null || _a === void 0 ? void 0 : _a.newValue) configureSentry(changes.environment.newValue);}));setTimeout((() => configureSentry(Environment.get())), 0);

Remote host receiving error-reporting envelopes

    • sentry-intake.datadoghq.com

    Datadog Sentry-compatible intake endpoint that receives Mixmax extension session and error-reporting envelopes.

Runtime configuration is fetched every minute

LowunwantedCWE-829Dynamic sandbox

Mixmax requested its runtime config from extension.mixmax.com three times at 60s intervals, updating storage key runtimeConfiguration_production.

What actually happens

You did this

You keep the browser open while the extension is running.

The extension did this

The extension checks Mixmax's runtime-configuration endpoint every minute and stores changed JSON in browser storage.

When this fires

Every 1 minute

The runtime-configuration check runs when the background script starts and then repeats once per minute.

Captured request

GEThttps://extension.mixmax.com/extension-runtime-config.json?cb=1776498047878

HTTP 200 observed on three requests at 60-second intervals; the fetched configuration updated runtimeConfiguration_production in browser storage.

Fields and storage touched by the configuration fetch

  • Configuration host
    extension.mixmax.com

    This is the remote host your browser contacts for extension settings while Mixmax is running.

  • Configuration URL
    https://extension.mixmax.com/extension-runtime-config.json?cb=1776498047878

    The full request identifies the runtime-configuration file and includes a changing cache-buster value.

  • Cache-buster value
    1776498047878

    A changing number makes each check a fresh request instead of relying on a cached copy.

  • Stored configuration key
    runtimeConfiguration_production

    The returned settings are saved locally so the extension can read them later.

The code that does this

The runtime-configuration fetch, storage update, and one-minute alarm

Readable version

Production extension URL resolver

background.js
getExtensionUrl() {    if (this.is(Environment.LOCAL))        return 'https://extension-local.mixmax.com';    else if (this.is(Environment.STAGING))        return 'https://extension-staging.mixmax.com';    else        return 'https://extension.mixmax.com';}

Runtime configuration request and storage write

background.js
async function checkRuntimeConfiguration() {    if (!navigator.onLine)        return;    // Cache bust the gate URL just in case the browser decides to cache.    const url = Environment.getExtensionUrl() + '/extension-runtime-config.json?cb=' + Date.now();    try {        const response = await fetch(url, { cache: 'no-cache' });        if (!response.ok) {            error_captureMessage('Non-200 response from S3', {                culprit: 'Querying the extension runtime configuration',                extra: {                    status: response.status,                    body: await response.text().catch((conversionError) => conversionError.message),                },            });            return;        }        const runtimeConfiguration = await response.json();        const runtimeConfigurationKey = `runtimeConfiguration_${Environment.get()}`;        // TODO: use promise API as soon as we're on Mv3        chrome.storage.local.get(runtimeConfigurationKey, (storage) => {            // The API docs for `chrome.storage.local.get` say `storage` should never be null,            // but we've found it sometimes (though rarely) is.            if (!lodash_default().isEqual(runtimeConfiguration, storage === null || storage === void 0 ? void 0 : storage[runtimeConfigurationKey])) {                void setStorage({ [runtimeConfigurationKey]: runtimeConfiguration });            }        });    }    catch (errorThrown) {        errorThrown.sentryExtra = { fetchUrl: url };        error_captureException(errorThrown, {            culprit: 'Querying the extension runtime configuration',        });    }}// Listen to `environment` changes to reload the configurationchrome.storage.local.onChanged.addListener((changes) => {    var _a;    if ((_a = changes.environment) === null || _a === void 0 ? void 0 : _a.newValue) {        // Give time for the Environment to be set        setTimeout(checkRuntimeConfiguration, 0);    }});// Check whether configuration has changed now (but give time for the Environment to be set)//// NOTE: this may prone to race conditions, but it won't affect production since it is the// default environment. We can try to revise it when we move to promise-based code after Mv3.setTimeout(checkRuntimeConfiguration, 0);// Check back every minute.const ALARM_NAME = 'runtimeConfiguration';chrome.alarms.onAlarm.addListener((alarm) => {    if (alarm.name === ALARM_NAME) {        void checkRuntimeConfiguration();    }});void chrome.alarms.create(ALARM_NAME, { periodInMinutes: 1 });

Remote host contacted for runtime configuration

    • extension.mixmax.com

    Mixmax extension runtime-configuration host; receives the cache-busted GET and returns JSON that is stored locally.

Mixmax version history

  1. 6.30.2

    Mar 4, 2026

  2. +29 more

  3. 6.68.0

    Nov 13, 2026

  4. 6.68.1

    Nov 15, 2026

  5. 6.70.0

    Nov 16, 2026

Chrome Web Store listing

Versions
6.70.0 latest of 33 seen since March 4, 2026
Store rating
4.8 from 560 ratings
Last updated
November 16, 2026
Size
14.79 MiB
Privacy policy
mixmax.com
Updated November 20, 2026