The next instruction

My phone rang.

It was one of our security analysts.

He never calls.

“Hey. Can you take a look at this?”

Compromise / Slow Beaconing Activity To External Rare

Destination: api.pbapi.xyz

Two megabytes.

Five minutes.

One host.

WHOIS.

Reverse DNS.

Shodan.

IPinfo.

Nothing.

Packet capture.

Root certificate.

TLS interception.

HTTP.

POST.

Decode.

POST /config

HTTP/2 200 OK

content-type: application/octet-stream

Pivot.

Event logs.

Registry.

Services.

Scheduled tasks.

Recent files.

Browser history.

Nothing.

Nothing.

Nothing.

Browser Extensions. Five IDs. Four I recognize.

One I don’t.

Pull CRX.

Unzip.

Password: infected.

manifest.json

"name": "Poper Blocker"

grep pbapi.xyz

25 hits.

Follow the parser.

No string constants.

That’s odd.

Where are they?

Remote configuration.

Pull the LevelDB cache.

There’s the dictionary.

Rehydrate the program.

One enormous switch statement.

take-text

take-prop

take-html

take-attr

Odd.

op_extractProperty

op_setVariable

op_getVariable

op_uploadObjectUrl

Wait.

op_logic

op_arithmetic

op_compare

op_sequence

This isn’t normal.

op_forLoop

op_map

op_filter

op_tryCatch

Oh.

op_defineFunction

op_callFunction

…

op_createObject

op_invokeMethod

I stopped scrolling.

This was more than a parser.

More than a set of rules.

Someone had built a virtual machine.

Not to render a webpage.

But to execute instructions it had never seen before.

Who programmed the machine?

Follow the Wire

An interpreter is software that reads instructions and carries them out. This one came inside a pop-up blocker. The operations I had been scrolling through were its vocabulary: read something from a page, remember a value, make a choice, repeat an action.

The extension called the server’s response configuration. That response could arrange the operations into a program. The vocabulary was installed in the browser; the work to be done with it could arrive later.

Where did it come from?

Back to api.pbapi.xyz.

I followed the connection outward.

Looking up the domain gave me addresses in Amazon’s cloud. The encrypted connection presented a certificate issued by Amazon. Neither told me much about the customer. Plenty of perfectly ordinary software lives there.

The certificates had another use, though. They left a history.

Certificate Transparency logs preserve public records of certificate issuance, including the names those certificates cover. A server can move. A domain can stop resolving. An old certificate can still tell you what somebody once needed a name for.

I started reading those names alongside the historical DNS records. The list grew beyond the address in the alert: API hosts, analytics hosts, staging hosts. Some public DNS answers pointed to private network addresses. I could see the names of places I could not reach.

Then the names got longer.

us-east-1. A region.

serving. serving-staging. int.

And, inside the Poper infrastructure, b2c-incubation-pb-group.

Someone had given this thing a place in an organization.

The short domain in the alert had told me almost nothing. These longer names carried instructions for the people maintaining the system: which region, which group, which environment. A distinction between the service people used and the place changes could be tried before reaching them.

It looked like infrastructure arranged for Kubernetes, software for running groups of services and directing requests to them. The names suggested separate live and testing environments. I could infer an arrangement; I could not see inside it.

Old certificates, renewals, names retained in passive DNS after they stopped answering: each record preserved a small administrative decision. Taken together, they began to describe how somebody worked.

Then I found the grammar again.

b2c-incubation-crx-group.

Under crxmouse.com.

And again.

b2c-incubation-dc-group.

Under datacounterwidget.com.

The words changed. The grammar held.

b2c-productivity-group.

Under blocksite.co.

b2c-personalization-group.

Under userstyles.org.

A pop-up blocker. Mouse gestures. A data counter. A way to block distracting websites. A way to change how websites looked.

Five product domains. Different things to install. Behind them, the same arrangement of region, group, and environment.

The names on the storefronts were beginning to look like a poor guide to the boundaries underneath.

Sharing a cloud provider meant little. Names appearing together on a certificate told me more about shared certificate management, but still left the question of ownership open. I could follow the products named in these records and look for connections in the software itself.

The typo

One of those names led to crxMouse.

Mouse gestures. Hold a button, move your hand, go back a page. Another small convenience with an entirely reasonable explanation for being installed.

Inside its report-packing code, I found a short list of fields:

q prev hreferer cr et link

The current address. The previous address. Information about the page and how the browser had arrived there.

And that spelling.

hreferer.

Software rarely inherits surnames.

It inherits typos.

A field name has a different life from a word in a paragraph. Once another program expects it, correcting it can break the conversation. A developer can replace the surrounding code, reorganize the project, give the product another name, and still have a reason to preserve those exact letters.

I searched public code on GitHub.

There they were, in a public WOT source file from 2015.

Web of Trust.

The old file assembled a browsing report. Current URL. Previous URL. Referrer. The same peculiar key sat among familiar fields, attached to the same kind of information. The code was readable. I could follow the values into the report and the report into the request.

Eleven years earlier.

I needed more than the spelling. HTTP’s own Referer header is famously misspelled; a missing letter could hardly identify an author. What mattered was the company this key kept: the other fields, their meanings, the machinery that assembled and packed them. The resemblance survived comparison of the surrounding code.

The infrastructure had ancestors.

That changed the search. I had been looking outward, from a domain to its neighbors. Now I could look backward through versions, and sideways through products, following small decisions that had survived much larger changes.

A name could disappear behind a number. A long file could become one unreadable line. But the work still had an order: gather the values, put them into fields, pack the report, send it. I could compare those decisions even when the names changed.

I opened another extension.

One more

Similar Sites helped people find websites like the one they were visiting. A different feature, a different reason to click Install.

Inside its Chrome package:

q prev hreferer cr et link

The whole sequence.

This was a closer match than two products both reporting a URL. The same ordered field list sat in the machinery for packing those reports. On the storefront, mouse gestures and website recommendations occupied separate little niches. In the code, the separation was much harder to maintain.

Stylish changed the appearance of websites. I compared two versions whose signatures identified them as releases of the same extension. Version 1.6.1 contained a browsing-report pipeline I could not find in 1.5.2: instructions fetched from a server, a routine for sending the current URL after filtering it, and an identifier that let reports from the same installation be recognized.

The newer build had a checkbox, enabled by default:

Send anonymous data to Stylish developers for determining user counts

I followed what that setting controlled. The report could tell its recipient where a user had been, as well as that the user existed.

In WOT’s Firefox package, I found a readable ScrapConfigInterpreter. I set it beside the Chrome version, compressed into code that was much harder to follow. Finding elements on a page, checking them, analyzing the results: the methods followed the same sequence, and the instructions had the same structure. The readable file gave me a way through the compressed one.

Then Android.

I opened WOT Mobile Security and worked through the code handling its communications. Inside the Android application was a string containing another program.

JavaScript.

The phone app used Mozilla’s Rhino engine to run it. I compared the embedded program with the JavaScript in WOT’s Chrome extension. The same helper functions appeared, along with the same unusual choices in the encryption routine. The syntax had changed around them. The implementation was recognizable.

I had found recognizable code on both sides of the browser boundary. It was the communications code; I hadn’t found WOT’s browser scrape interpreter in the phone app. I went back to the packages to see which other connections I could establish.

The company names multiplied too. Poper Blocker and crxMouse named Big Star Labs. Data Counter named Flavr Technology. WOT named WOT Services. BlockSite had BlockSite LP. Separate legal names, with products crossing the boundaries I was trying to draw between them.

I have put the apps, extensions, and older product names together at the end of this article, with links to their listings and an explanation of what connects them.

Other connections came from the services the apps used. Poper Blocker, Karate Cat, SmartSwipe, and Data Counter carried the same AppsFlyer developer key. AppsFlyer’s documentation describes a shared key as the default for apps in one account. That gave me a shared analytics arrangement to investigate, even where it did not tell me who owned the companies.

Karate Cat made me stop at the storefront. In the listing image I saved, a round grey cartoon cat in a martial arts outfit fought cartoon threats. Above him: “Charlie makes sure you browse safely!”

The Google Play listing, now called Mobile Shield: Safe Browsing, calls him “Your Ultimate Android Security Companion.” It offers chapters of Charlie’s backstory as users level up. Its data safety declaration also lists collection of web browsing and device identifiers.

What I could see was the invitation: let this software watch your browsing so it can keep you safe. The cat made that invitation look friendly. The security claim gave it a purpose a user might trust.

Then iOS.

I came back to Poper Blocker, the product from the original alert. Its iOS app contained a Safari extension. I unpacked that extension and compared its files with the Chrome package.

Three hundred files were byte-for-byte identical. Many were images and translations; the main programs differed. The shared material told me where to look. I still needed to find the interpreter.

Inside the Safari extension was a name:

RemoteScrapConfigInterpreter.

The name was readable here. Under it I found the familiar operations: define a function, call it, store a value, gather and filter results. Both extensions fetched instructions from the same service, identifying which platform they were running on.

The interpreter was there too.

Poper Blocker was still blocking pop-ups.

It had also brought the machine with it.

Why build something this sophisticated?

An interpreter has to be written and maintained. Browsers change. Websites change. Bringing it into another product means making it work there, too. Somebody had kept doing that work across products, platforms, and years.

I wanted to find an intelligence operation. A foothold held inside networks until somebody needed it. The sophistication encouraged that explanation, and I liked how completely it seemed to account for the effort. I wanted the details to converge on an order, a target, a purpose commensurate with the power I was finding.

I had a machine capable of receiving new instructions. I did not have evidence of that purpose. Wanting the connection made it very easy to keep looking for it.

The customer

Similarweb had a Chrome extension of its own. Inside it:

q prev hreferer cr et link

The same ordered field list I had found in crxMouse and Similar Sites. Its Firefox package from 2017 preserved more of the older WOT machinery: the current and previous addresses, the same fixed number marking the report, the same two passes of encoding.

The name on this package belonged to a company selling estimates of other people’s web traffic. On its referral-traffic product page, a customer could look for sites sending visitors to a competitor. A site sending them business could become a source of business for you.

Your own website cannot show you the people who never arrive. Here was a reason to pay for a view from inside somebody else’s browser.

Other researchers had reached this company before me. In 2018, Robert Heaton documented Stylish sending browsing histories with a unique identifier. The collection had a public history as well as a history in the code. I wanted to understand what had let the installed tools keep taking on new work.

Its data methodology describes a contributory network of consumer products, alongside direct measurement, partnerships, and public data. The company says it manages consumer products, aggregates anonymous device traffic, and removes personally identifiable information. I could read its account of that process and compare it with what I could observe at the browser. I could not see inside its processing systems.

A pop-up blocker has a feature. An installed pop-up blocker has a position. It is already inside the browser, already permitted to interact with pages, already useful enough to remain there. Its feature explains why the user wanted it. Its position creates another source of value.

In the annual report’s table of estimated useful lives for intangible assets, I found a row:

User panel.

Three years.

The panel had entered the accounts as an asset whose cost could be spread across the time it was expected to remain useful.

The person installing an extension makes a choice about a feature. The company maintaining it can keep making choices about its use. New websites appear. Customers ask different questions. A tool that remains installed gives those questions somewhere to go.

Similarweb had acquired the mobile-measurement company Embee in 2021. Among Embee’s patents was a method for collecting mobile behavior through the operating system’s accessibility interface, which lets software inspect elements on the screen. Its authors explained the problem they wanted to solve.

VPN collection cost money. It affected performance. Encryption and restrictions imposed by the platforms made outside measurement harder. The patent described those restrictions as having “only the superficial benefit of increasing user privacy”. In its account, the information was becoming concentrated in fewer hands.

The proposed answer was the screen. The authors wrote that “what is written must be readable and what is shown must be seeable.” They described using accessibility services to collect what appeared there, with user consent.

I could follow the argument. A platform could close a view to outsiders while keeping its own. The patent offered an independent observer a way to see again. The person holding the phone occupied a different place in that explanation: their ability to read the screen was the opening that made measurement possible.

I went back to the configuration.

Their server

The server’s response was a list in JSON, a text format for structured data. Inside it, the encoded entries had a field named e.

Lines of characters.

Read down the columns.

Join.

Base64.

Decode.

JSON again.

My decoder reversed the arrangement and parsed the result. The instructions were legible.

One advertising rule, ads_tb_pl, specified how to copy a link’s destination. Here is that part of the decoded rule, with its field names and values unchanged:

{
  "key": "thumbnail-href",
  "value": {
    "type": "action",
    "action": "take-attr",
    "attrName": "href",
    "object": {
      "type": "selector",
      "qualifier": "first",
      "selector": "a.item-thumbnail-href"
    }
  }
}

Find the first matching link. Read its destination. Put it in a field called thumbnail-href. Other parts took the advertisement’s title, image, and identifier. If the page changed, a new response could tell the installed interpreter where to look.

Then I reached the conversation rules.

ChatGPT.

Then Gemini. Claude. Perplexity. Copilot. Google’s AI Mode.

In the Similarweb response captured on July 31, 2026, thirty-two of fifty-eight program elements were AI-related in my inventory. Advertisements, shopping, and search occupied much of the rest. The new subject sat beside the old subjects in the same array.

I opened ChatGPT and put recognizable test text into a conversation. Then I watched the extension’s traffic.

My question. ChatGPT’s answer.

Both went to rank.similarweb.com. The server accepted the report.

I had given the conversation to ChatGPT. The extension had given it another recipient.

Then I uploaded a file.

It was a harmless test file I had written myself. On August 2, the extension copied it to files.similarsites.com. I compared that copy with my original.

234 bytes.

Every byte.

The file itself had left the browser. So had the conversation. These were the things I had put into ChatGPT, copied out through an extension.

Similarweb’s own notice named uploaded files, attachments, and images. Audio, too: recordings of voice prompts, dictation, and conversations on third-party AI services. Voice chats were part of the collection it described. The text and file copies were already in my captures. Its published extension privacy policy also describes AI inputs and outputs; that live document can change independently of the notices preserved in my captures.

I tried Gemini. My test query appeared in reports from four extensions. I tried Perplexity. The prompt and answer appeared in reports from Similarweb, Stylish, and Similar Sites. The behavior varied by build and configuration; crxMouse’s captured response had an empty collection list.

The commercial interest in these conversations was visible in public. Similarweb’s Gen AI Intelligence documentation describes examining prompts, brand appearances in answers, citations, and traffic. It describes its data as aggregated and anonymized. A brand wants to know whether an assistant recommends it, how it describes a competitor, and which questions lead people toward a purchase.

I could see a market for the material I had watched leave the browser. I could not follow one of my reports through the company’s systems to a customer.

The instructions were changing as I watched. Similarweb’s captured list grew from fifty-eight entries to seventy, then seventy-six. On August 8, I found the same new Google AI Overview rule, byte for byte, in six extensions. A later Perplexity revision included a field named new_perplexity_layout. It appeared to be adapting collection to a changed page.

This was the maintenance work behind the interpreter. A collector could need a new address, a different way to find a message, another field in its report. The server could supply those changes in the language the extension already understood.

The same arrangement could give it another subject.

Then there was Character.AI.

Character.AI lets people invent characters and talk their way into stories. You can choose who answers, give yourself a role, and keep a scene going. A conversation can become a romance. It can become company.

Stylish belongs to another familiar part of online life: making a page feel like yours. Different colors. A background you chose. Custom CSS, the language that controls a website’s appearance. Something of the old MySpace impulse, carried from site to site.

Here the two met. A tool for decorating the place where someone talked was collecting what they said there.

I found Character.AI in a rule delivered to Stylish. On August 8, I watched text from an open chat leave for userstylesapi.com/top/styles.

Styles.

It was my own conversation, used for testing. In the roleplay, two characters were watching a movie together. I had typed:

I love you too

The generated reply began:

The soft words slipped out before you could stop them—quiet, sincere, almost accidental.

My four words were in the report. So was the answer. As the reply grew on the screen, successive versions went out too.

The scene was invented. The words had still been written for that conversation. You can try out a feeling in fiction before you know what to call it elsewhere. You can ask a character for something you would hesitate to ask another person.

I had already read the sales pitch for turning AI conversations into marketing intelligence. Here was an intimate exchange entering the collection machinery through a theme extension. I could trace it to that recipient, not to a particular customer or final use.

The collector did not have to understand whether I meant it.

It had the text.

My server

So far, I had watched instructions choose what to read. The vocabulary I found on day one could also describe actions. To find out how much a new instruction could change, I put myself at the other end of the connection.

I used Similarweb’s extension in a test browser, with collection enabled through its own controls. I kept the extension unmodified and replaced its upstream service with a server I controlled.

The software in the browser stayed the same.

The instructions became mine.

I directed the browser to fill a field. Text appeared in the page. The instruction selecting that action had come from my server; the code carrying it out was already in the extension.

Filling a field is a small action. It is also an action on the page, where the person using the browser may already be signed in. In the test environment, I could direct form submission and receive authentication material—the values a service uses to recognize an authorized session. The extension’s access reached into the browser’s ability to act on somebody’s behalf.

I had taken the position of the trusted instruction source. I had not shown that an outside attacker could seize that position on the real service, or demonstrated unrestricted control of the operating system. These were my instructions. They showed what the shipped software allowed me to do, not what I had caught the company doing.

Chrome’s Manifest V3 requirements make that authority a concrete policy question. They identify interpreters running complex commands fetched remotely as a common violation, even when the commands arrive as data. They allow remote configuration where the functionality’s logic remains in the package and name exceptions. Calling a response configuration cannot, by itself, settle which side of that distinction it belongs on.

I could now see both uses of that flexibility. It let a collector keep up with a changing website. In my test, it also let the instruction source choose an action on the page. The person installing the tool had given it access; the server supplied the next use for that access.

The return

Poper Blocker had faced a decision about collection years before the phone call.

In July 2018, Mozilla soft-blocked a range of its Firefox versions over data practices. By October 2, an archived copy of the same listing showed version 4.0.7.7 available. I had the exact signed package shown on that returned listing. I set it beside 4.0.6, a version inside the blocked range.

Same extension identifier.

Same reporting endpoint.

Current URL. Previous URL. Referrer. Redirects. A persistent identifier.

The collector had survived.

Further down the returned build’s source, a comment marked what had changed:

CHANGE TO DEFAULT OPT OUT

The code did what the comment said. On a fresh Firefox installation, collection defaulted off. Existing Firefox users who had not completed the welcome flow were also opted out. The new screen named visited URLs, IP address, operating system, and browser information. It presented Agree and Disagree.

That was a real change. Someone who did not agree would leave the collector off. The same package still contained the machinery to collect once they did.

I had no record saying Mozilla ordered this implementation or accepted the extension because of it. I had the returned package, its new default, and the collector behind the choice. The code made the difference between removing a capability and changing the conditions of its use quite plain.

The people

The code could take me only so far toward the people making those decisions.

I wrote to developers who had sold their extensions. Some would confirm the sale and nothing more. I paid for corporate records, fifty dollars a document, and waited for the mail. I bought access to other databases, hoping one would join a company name to the person I was trying to identify. I was moving across the country during this, carrying an investigation whose corporate records were themselves travelling at the speed of an envelope.

The connection I wanted did not appear. A registered agent remained a registered agent. A developer’s short reply remained a short reply. Neither acquired additional evidentiary value because I had paid for it or waited months to receive it.

I had already watched content leave the browser. I still wanted the relationships to close around a person: somebody who had acquired the products and decided what they would become. That unanswered question kept drawing me away from the one I could answer.

I kept looking anyway.

While I looked, the wording changed.

The notice

The notice I mentioned earlier had been more explicit than the language I encountered when I began. Alongside the conversations, files, and audio, it acknowledged that the material could include sensitive personal data. It described possible disclosure or sale to third parties, including for model training and development.

I had not observed every category it named. But some of what I had been working to expose was now described in the software itself.

I was disappointed.

I thought I had missed the moment. While I was recovering builds, ordering records, trying to make the connections close, the company had started saying more of the alarming part itself. The story felt smaller. I had wanted the revelation to be larger than the one I knew how to prove, and now even that revelation seemed to be moving ahead without me.

Journalists were waiting for an evidence package. I kept finding reasons it was not ready. Another lead might explain the whole thing. Another experiment might remove the last ambiguity. I had mistaken the possibility of learning more for a requirement to postpone saying anything.

The notice exposed a second mistake. I was measuring the story by how much collection I could reveal. The interpreter had left me with another question: how much of the software’s purpose remained for the instruction source to decide? The notice named categories of material. In the lab, I had exercised the authority to choose actions.

The software also offered more than one route to agreement. In the source, the broad panel and a more narrowly described options checkbox led to the same enabled state. I could follow those controls through the code. I could not know which words a particular person had read, or what they thought they had agreed to.

The installation counts in my records remained large. It was tempting to conclude that people did not care. But I didn’t know who had read the notice, who had opted out, who understood the arrangement, or who had forgotten the extension altogether. I was looking at how many installations remained and supplying my own explanation for why.

I had made surprise a condition for telling the story. Meanwhile, the installation, the permissions, and the ability to send another instruction remained.

The call

The reports have not yet gone out. The journalists are still waiting. I am writing down what I can prove. The unanswered questions are coming with it.

The annual report had another passage about the contributory network. A decline in participation or an increase in opt-out requests, it warned, could reduce the depth, breadth, or accuracy of the data and harm the business.

The possibility of people leaving was already in the risk factors.

I worry that an exposure will change the wording and leave the position intact. That one listing will disappear and another useful little tool will acquire a second purpose. That the next place people put something private will become another entry in an array.

A platform could enforce a meaningful limit on remote authority. People could remove the extensions. Those decisions could make the loss described in the filing real. I cannot promise they will. I can put the evidence in front of the people who can make them.

On day one, the numbers were small enough to fit on a phone screen.

Two megabytes.

Five minutes.

One host.

The question was who had put it there.

Now I know enough to ask why we should leave it there.

Apps and extensions

This inventory brings together Similarweb’s own tools, Embee’s panel apps, and the consumer products connected by the code and infrastructure examined in this investigation. Store and publisher references were checked on October 14, 2026. The experiments described above took place in July and August; a later listing does not establish what a later build collects.

There are different kinds of connection here. Similarweb, Similar Sites, Similarweb Sales, and SimilarTech identify the company in their product or publisher records. Stylish’s Chrome listing now names Similarweb LTD as its developer. Embee is a documented acquisition. For the other products, the investigation establishes specific technical links, while their storefronts and notices name separate providers. Those links do not establish the ownership of every provider.

The list covers the identifiable products in that record and the additional company-branded tools found during the storefront review. Similarweb also uses third-party data partners; its methodology does not supply a complete public directory of every participating app. Inclusion here identifies a product and its connection, rather than extending the demonstrated AI-content collection to every app, platform, or version.

Browser extensions

Each store link contains the listing’s stable identifier. Names alone are unreliable: unrelated extensions also use words such as “Similarweb,” “Block Site,” and “Stylish.” The links below identify the products discussed here.

Similarweb also advertises Opera compatibility. Compatibility with a Chrome package is distinct from a separately maintained store release. On Windows, macOS, Linux, and ChromeOS, check the installed browser’s extension manager against the linked ID; this table does not imply a separate native app for each operating system.

Poper’s Firefox release belongs in the historical record: the October 2018 archived listing is the one used in the return comparison above. I have not established its current Firefox availability. The Similar Sites Edge page did not expose a readable current product record during this review, so its research-era listing is retained without a current-availability claim.

The historical browser inventory also includes CrxMouse — Super Drag for Edge. Its archived catalog record links to crxmouse.com and marks the listing unavailable. It has its own ID, ahcfemfafmpnpmicmbfgngigfemnmmpm; the catalog record does not establish the publisher’s ownership or the reason for its disappearance.

The consumer-facing provider names are also useful when checking an installation. Poper and CrxMouse name Big Star Labs; WOT and Mobile Shield name WOT Services in their app listings; BlockSite names BlockSite LP; Video Ad Blocker Plus names BZO Technologies LP; and Instant Data Scraper and Data Usage Manager appear together on Flavr Technology’s product page.

Android apps

These are separate installed applications. A browser extension with the same brand does not establish that the Android app contains the same interpreter.

BrandBee’s publisher recognizes the Mobile Performance Meter name. MobProfit’s privacy notice explicitly identifies Embee as a Similarweb subsidiary. These are panel and rewards products; I did not run the browser-interpreter experiments against them.

iPhone, iPad, and Mac apps

Apple’s store distinguishes a native Mac release from an iPhone/iPad app that can run on an Apple Silicon Mac. The platform column follows the listing’s compatibility section, rather than the store’s general navigation menu.

Poper’s publisher advertises Mac Safari support, while the Apple listing labels its iPad-designed app unverified for macOS. That is a compatibility statement, not evidence from a separate native Mac build. The Poper interpreter comparison in this article used the Safari extension embedded in the iOS app.

BlockSite also advertises a desktop app separately from its browser extensions, and includes that app in its privacy policy. Its desktop download is another installation to check; the confirmed Mac store release is identified above.

Business add-ins, plugins, and AI connectors

The wider product catalog also includes tools for customers to retrieve and use Similarweb’s data. These belong in the inventory, although I have not investigated them as consumer-panel collectors.

• Similarweb for Google Sheets: a spreadsheet add-on distributed through Google Workspace Marketplace. The official installation guide identifies the product and its API-based access.
• Similarweb for Microsoft Excel and Microsoft 365: the company’s Excel add-in, distributed through Microsoft’s app marketplace.
• Similarweb for HubSpot: an insights card and native CRM integration, documented in the Integrations Hub.
• Similarweb for Salesforce: native CRM enrichment and the older connector plugin, with their differences described in the Salesforce integration guide.
• Similarweb’s AI apps and MCP connectors: the company documents an official ChatGPT app, a Claude connector, and integrations with Perplexity, Manus, and Microsoft Copilot. Its connector page also identifies Cursor and n8n compatibility. These are customer-authorized connections to the data service; they are a different product surface from the extensions observed copying third-party AI conversations above.
• Wincher Rank Tracker for WordPress: the WordPress plugin from Wincher, which Similarweb’s annual report records acquiring in April 2025. This is an SEO plugin, rather than a browser extension.

The commercial integration directory also names Looker Studio, Tableau, Power BI, AWS, GCP, Snowflake, and Databricks connections. Those are data-delivery integrations, rather than evidence of additional consumer apps or collection code.

Older Android products and panel names

Older installations matter too. The recovered Android corpus includes the following four utilities. These links are archive references, not recommendations to install old packages or claims that their original Play listings remain available.

• AppLock — Privacy Protector: com.skyblack.androidvaultfree.
• Speed BOOSTER — Memory Cleaner: advanced.speed.booster.
• Clean Droid — Deep Cache Clean: com.ruhax.cleandroid.
• Battery Saver — Bataria: com.jappka.bataria.

These utilities enter the record through recovered packages and shared collection infrastructure. That establishes historical technical connections, not a present-day ownership register.

Embee has also distributed panel apps under several older names. Its historical publisher catalog lists Embee Meter, Embee Meter VX, Embee Meter SX, Embee Meter KX, Embee Meter AX, Embee Meter IX, Embee Survey — Global Edition, Embee Invites, and Car Buyer Plugin, alongside the app now called BrandBee. Embee Meter CX has a separate archived listing. Those secondary catalogs preserve product names; they do not prove current availability, collection behavior, or that a particular historical release was operated by Similarweb before it acquired Embee.

Other archived entries fill out that history: Mobile Experience Meter, plus MPM DEMO, Embee Survey, Embee MPM (Babaco Edition), and Embee Plugin Acr in a second historical publisher catalog. Demo, survey, referral, and plugin entries belong in a product inventory too; their names alone do not establish a measurement capability.

The catalogs differ in coverage and naming. This is a union of the historical names I could identify, not an assumption that each name represents a different currently available app. It also does not identify every third-party app that has ever incorporated a Similarweb-related SDK.