Website SDK
One script tag connects your website to The AI CMO: visits, conversions, and revenue flow into your warehouse, journeys can react to what people do on your site, and website messages from Journeys render on your pages.
Install
In the app, open your account menu and choose Website SDK. Add your
site by domain and you get a snippet to paste before </head>:
<!-- The AI CMO -->
<script async src="https://theaicmo.com/sdk/v1/tracker.js"></script>
<script>
window.AICMO = window.AICMO || [];
AICMO.push(['init', { siteId: 'lpo_your_site_id' }]);
</script>
That's the whole install. The script loads asynchronously and cannot block or break your page – even if analytics is unreachable, your site is unaffected.
To confirm it works, press Check again on the Website SDK page. It fetches your page and looks for the tag and your site key, and tells you what it found: installed, the tag carries a different site key (a snippet copied from another site), the page could not be reached, or not in the page HTML – which, if you install through a tag manager, only means the tag exists in the browser; the script then reports in by itself the first time a page loads. The page also re-checks quietly every few seconds while it waits. The signals, in order:
- "Installed – the tag is on yoursite.com" or "Script loaded – seen on yoursite.com just now" – the tag is in the page, or the script ran on your site and fetched its settings. Either is the install confirmation.
- "Receiving data – last seen …" – data is arriving. The first page view after the tag is live is enough; a conversion, a form submit or an identify call (the two extra lines of code in the next row) adds revenue and identity on top. The page banner then reads "SDK installed and receiving data".
If it still says not seen on the site yet, open a page that carries the script tag with a hard refresh and without an ad-blocker, then check again.
One site, several brands
A site belongs to the brand it was added on. When another brand of yours – a test brand, say – needs the same website, share the site instead of installing it again. On the Website SDK page of the brand that owns the site, open Other brands and choose the brand to share it with; on the other brand, the same page offers Use an existing site. The shared brand sees the same key, the same install state and the same settings, and can register events for it.
Two things stay put. Events land under the brand the key belongs to, and the snippet, settings and removal are managed on that brand. Brands that share a site share their event registrations: a key registered on either brand is accepted by the site and listed under Data → Events on both.
To rehearse an event-triggered journey on a test brand, add a site to the test brand and use its key on your staging environment. The tracking code stays identical; only the key differs.
What web analytics records
Web analytics records page views on every site, always: each page a
visitor opens (including single-page app navigation), with where they came
from, so visitors, sessions, channels, campaigns and landing pages are there
from the first day. Page views are always sent with who the visitor is: a
signed-in visitor who allows marketing is named with their page views (your
identify call), so their visits reach their Activity, audiences and
journeys. Page views are not a switch, and neither is who the visitor is.
Everything else is: clicks, scroll depth, forms, speed and the rest are
recorded only once you switch them on, site by site, on the Website SDK page
under What the SDK records, and every one is off until you choose it: see What
the SDK records, and what you switch on.
Your business moments, conversions, revenue and identity you declare
explicitly with the calls below, and they reach your warehouse whatever is
switched, so your analytics contains what you decided matters, not noise.
On a site with a consent banner, all of this runs only as far as the visitor allowed – see Consent and privacy.
Session recording, heatmaps, and automatic click capture are switched off by design: they multiply event volume without adding decisions, and they are the first thing a privacy review flags. They are not switches: they stay off on every site.
Conversions, form submits, sign-ins and sign-ups (your identify calls,
recorded once each: see
Identified: a sign-in or a sign-up),
your registered custom events
and website-message interactions land in your warehouse with an sdk_
prefix on the event type, attributed to the visitor and – once they
identify – to the person. No switch decides them: they arrive with every
switch off.
Behaviour (page views, how far each page was scrolled, each step down a
page, buttons and links clicked, buttons and page elements seen, exit
intent, rage clicks, forms started and abandoned) is read from the
analytics layer and copied into your warehouse about every ten minutes as
web_ events – web_scroll_depth, web_cta_click, web_form_abandoned
and so on – so audiences and journeys can use them like any other event.
Each web_ event arrives only from a site with its own switch on:
web_scroll (each step down a page) arrives only from a site with Scroll
milestones switched on, web_cta_click only with Clicks, and so on;
web_page_view needs no switch, as page views are always sent with who the
visitor is. Only what an identified visitor did crosses:
identifying someone needs their marketing consent, so a visitor who allows
analytics alone is never identified and their behaviour is never used for
marketing, and an anonymous browser never becomes a contact. A visitor who
withdraws marketing on a page where they were already identified is the
exception until the next page load – see When the choice expires or is
withdrawn. The web_ copies do
not count toward your warehouse volume (your web analytics volume counts
them). Each person also gets one daily site_activity row (sessions,
pageviews, top pages), from every site; it counts toward your warehouse
volume.
What the SDK records, and what you switch on
Always on, with no switch, whatever is switched below:
- page views: every page a visitor opens, with where they came from, in web analytics (Overview, Live, Acquisition, Pages, Goals, Audience and Campaigns are built from them);
- who the visitor is, with the page views: a signed-in visitor who allows
marketing is named in web analytics (your
identifycall), and which of your sites the visit is on goes once a session, so their visits reach their Activity, audiences and journeys; - conversions and revenue (
trackConversion); - who the customer is (
identify), and contact details given in a website message's sign-up box; - your own events (
track,data-aicmo-eventand the events set up under Data, Events); - forms submitted (
sdk_form_submit); - the record of each visit and its source (see Every visit, with its source);
- consent and its record, website messages, the inbox, web push, personalization, Site chat and site tests (which version a visitor sees, and the goals they reach).
All but page views and who the visitor is in web analytics reach your warehouse first-party, also on a page where the analytics script does not run (the visitor's consent, a blocker). Where it runs, your own events and conversions go to web analytics as well.
Everything else is a switch, and each one is off on every site until you switch it on, existing sites included. The switches, grouped as on the page:
Clicks and attention
| Detail | What it gives | Needed for | Warehouse event |
|---|---|---|---|
| Clicks | Clicks on buttons and links, with the button's text and where it leads. | Engagement's top buttons and Live, a person's Activity, the AI CRO analysis, and audiences and journeys on "clicks a button or link". | web_cta_click |
| Rage clicks | Repeated clicks on one spot that do nothing, a sign something looks clickable and is not. | Engagement and Live, and audiences and journeys on "rage-clicks". | web_rage_click |
| Buttons seen | Which buttons and calls to action each visitor saw, and for how long. | Live, a person's Activity, the AI CRO analysis (which buttons were seen and not clicked), and audiences and journeys on "sees a button". | web_cta_seen |
| Elements viewed | Which headings, videos, pricing and testimonial blocks (and anything marked data-aicmo-track) each visitor looked at. | Live, a person's Activity, the AI CRO analysis, and audiences and journeys on "sees a page element". | web_element_seen |
Reading
| Detail | What it gives | Needed for | Warehouse event |
|---|---|---|---|
| Scroll depth | How far down each page a visitor scrolled in the end, and how long they stayed: one event as they leave the page. | Engagement's average scroll depth and the Pages report's scroll column, Live, the AI CRO analysis, and audiences and journeys on "leaves a page (how far they scrolled)". | web_scroll_depth |
| Scroll milestones | Each step down a page as a visitor reaches it (10, 25, 50, 75, 90 and 100 %). | Journeys that start when someone scrolls 75 % down a page, and the AI CRO analysis's step-by-step drop-off. | web_scroll |
| Page leave | The moment a visitor leaves each page, which time on page and session length are measured to. | Session length and time on page in Web analytics, and Live. | none |
Forms
| Detail | What it gives | Needed for | Warehouse event |
|---|---|---|---|
| Forms | Forms a visitor starts filling in, submits and gives up on, with the last field they were in. A submitted form reaches your warehouse either way. | Engagement's form counts and Live, tracked-link conversions from your site's forms, and audiences and journeys on "starts filling a form" and "abandons a form". | web_form_started, web_form_abandoned |
| Form-field timings | Every field a visitor clicks into and how long they spend in it, for finding the field where a form is given up. Form interactions on Engagement then counts every field instead of each form started. | Engagement's Form interactions and Live. | none |
Speed
| Detail | What it gives | Needed for | Warehouse event |
|---|---|---|---|
| Speed | How fast each page loads for real visitors (Core Web Vitals: LCP, FCP, CLS and INP) and the page load timings. | The Vitals report, the speed columns of the Pages report and the Tracking report's vitals count, and Live. | none |
Exit intent
| Detail | What it gives | Needed for | Warehouse event |
|---|---|---|---|
| Exit intent | When a visitor's mouse heads for the top of the window to leave the page (desktop only), once a page. | Engagement and Live, the AI CRO analysis, and audiences and journeys on "shows exit intent". | web_exit_intent |
Two switches that work together. Form-field timings records nothing while Forms is off; it adds to Forms. Behaviour reaches a person only once web analytics knows who they are, and with page views always sent with who the visitor is, it does for every signed-in visitor who allows marketing, on every site: no switch is needed for it.
Who switches them. An owner or administrator of the site's brand, on the Website SDK page under What the SDK records. Every change is recorded with who made it and when. Managers, editors and viewers see the switches but cannot change them, and a site shared into another brand is switched on its own brand.
When a change takes effect. Your visitors' pages pick it up within about 5 minutes. A page that cannot read the site's settings, or does not get them within 2 seconds, records only page views and who the visitor is, as if nothing were switched on; settings that arrive later switch nothing on for that page. If they say visitor analytics is off for the site (it is paused, or this visitor is outside its sampling share), it stops on that page, and that visitor's next page waits for the settings before it records anything.
What it costs. Page views count toward your account's web analytics volume (see Included analytics volume), one event for each page a visitor opens; who the visitor is adds an event when a visitor is identified and one for the site's details once a session; and each switch adds events to it. The page shows an estimate for each switch from your site's own page views of its last 7 days with page views, and a total with page views, who the visitor is (at what a busy site sent for each page view, and it says so) and what is switched on. Where your site already counts a capture itself (page views, rage clicks, exit intents, forms), the estimate uses that count; otherwise it uses what a busy site sent for each page view with the switch on, and says so. It is an estimate: how many events your pages send depends on how many buttons, headings and forms they carry.
What goes quiet while a switch is off. Its events stop arriving. Every report that reads it (each Web analytics report, Live, the Tracking report, a person's Activity, AI CRO, the report builder's funnels and tracked-link conversions) says the capture is switched off for the site and links to the switch, and a figure with nothing recorded reads "off" instead of a zero. Audiences and journeys on that behaviour get no new events: the event pickers say so beside them, and the journey builder says so under a trigger, a wait, an If / else condition or a rule that uses one (nothing is blocked). Everything recorded before a switch-off stays, for its dates.
Rage clicks on touch screens. On a phone or tablet a rage click is 4 or more taps within 1.5 seconds on one small spot, with nothing on the page changing in between (no scroll, no navigation, no change to the page), so quick ordinary taps are not counted. With a mouse it is 3 clicks within one second on one spot.
Attribution: first click or last click
The SDK keeps a touch ledger per visitor: their first-ever arrival (source, medium, campaign, referrer, landing page, timestamp) is recorded once and never overwritten, and their most recent campaign or referral arrival updates alongside it. Direct return visits never erase a known source – the same "last non-direct click" convention the big analytics suites use. Both touches ride on every conversion and revenue event, stored in your own warehouse.
Which touch your reports credit is a per-brand setting: last click (the default) or first click. Because both touches are stored raw on every event, changing the model later never loses data – reports state the active model next to the numbers, and history keeps enough to be re-read under either. Attribution starts when the SDK is installed, and journeys that span devices connect once the person identifies on both.
Every visit, with its source
From version 1.31 of the script, every arrival is also recorded on its own,
with its time – the visit history behind first-touch, last-touch and
position-based reports, new-customer figures and marketing-mix inputs. An
arrival is a page load that is tagged (UTM parameters, a tracked link, an ad
click ID), comes from another site that is not part of your own journey (see
Where visits come from), or is the browser's first
visit. At that moment the script sends one small touch request to your
first-party endpoint. What is recorded:
- the source, medium, campaign, content and term the visit was tagged with, and the referring site;
- the landing page as its host and path – never the full address or its
query; the only part of the query kept is a journey link's own
aicmo_r; - the ad click ID this landing carried, and which kind it is (Google, Microsoft, TikTok, Meta);
- the landing time, the random visitor ID, and how marketing was allowed: a yes on your banner, or a site without consent mode.
It is sent only when the visitor allows marketing. It names nobody: no e-mail, no customer ID and no identity is recorded with it, and it is not a warehouse event, so it never counts toward your warehouse volume. A visit becomes part of a person's history only through the devices their own identity already links, and only while that person allows marketing. Visits from a page that is not on your site's domain (localhost, a preview host), or from a test brand, are kept apart as test traffic. Repeats are dropped (the same arrival sent twice, or the same visitor arriving the same way within 30 minutes), and a day's touches are capped per visitor and per address.
Each visit is kept for 25 months, its ad click ID for 90 days; a daily count per channel without any personal data is kept for as long as you use the service. The visits of a person you erase are erased with them, and a browser of an erased person records none. Visits before the script reached 1.31 are not in this history – it starts on your site the day the new script loads there, and older visits are never filled in.
Where visits come from
Every visit is filed under one channel, by one rule shared by the visit history, web analytics and your imports: Direct, Organic search, Paid search, Paid social, Organic social, Email, SMS, Affiliate, AI referrals, Display, Marketplace, Referral or Other campaigns.
- A Google Ads click (
gclid,gbraid,wbraid) or a Microsoft Ads click (msclkid) is paid search, with or without UTM parameters. - A Facebook click ID (
fbclid) on its own is organic social: Facebook adds it to every link people click there, ads or not. Tag your Meta ads withutm_medium=paid_social(orcpc) to count them as paid social. - A visit from webmail (Gmail, Outlook, Seznam e-mail…) is e-mail, and
utm_medium=affiliateis the Affiliate channel. utm_source=googlewithout a paid medium is organic search;cpc,ppcor the name of an ad product makes it paid.
Some referring sites are never an arrival from somewhere else: your site's own domain and its subdomains, localhost, our app, payment and 3-D Secure pages, and sign-in returns. A visitor coming back from them keeps the source they came with. Your own journey may pass through other hosts – a game provider, a booking engine, a payment page we do not know. Add them on the Website SDK page under Where visits come from: it suggests the referring sites of your last 30 days of web analytics, and you confirm the ones that are part of your own journey, up to 50 a site. Search engines, social networks, AI assistants and webmail cannot be added – those are real arrivals. Confirmed hosts apply to the visit history at once, to the last touch on conversions, and to web analytics from its next update.
Web analytics also learns which kind of ad click a visit landed with. The
script registers aicmo_click on the visitor analytics' page properties –
google, bing, tiktok or facebook, never the click ID itself – so a
Google Ads click without UTM parameters is paid search in web analytics too.
It names no one, so it is set with analytics alone, without marketing, and
rides with the other page properties (the page address, the referrer).
The rules started on a date, and the Channels report in web analytics
and the Website SDK page both show it. The Last 7, 30 and 90 days views are
refiled by the current rules as a whole, every 15 minutes. In a custom date
range, days rolled up before that date keep the filing they had: a Google
Ads click without UTM parameters as organic search, webmail as organic
search or referral, no Affiliate channel. Web analytics never counted an
fbclid as paid social; Shopify orders and website conversions that
carried only an fbclid did, and are organic social from that date.
Included analytics volume
Visitor analytics is included with your plan. How many events a month that covers depends on the plan you are on – your plan page carries the number. Conversions, identity, custom events, journeys, and revenue tracking are never counted against it: it meters only the behavioral layer (pageviews and sessions).
With nothing switched on, a site sends its page views to web analytics, one event for each page a visitor opens, with who the visitor is (an event when a signed-in visitor is identified, and one for the site's details once a session), and nothing else. Each switch you turn on (see What the SDK records, and what you switch on) adds to the volume, and the Website SDK page estimates by how much before you do.
If a site outgrows its plan's volume, nothing breaks and nothing is lost silently: visitor analytics switches to sampling (1 in 10 visitors), you get an alert, and full detail returns when volume drops or the plan grows. First-party data – conversions, revenue, journey events – is never sampled.
When your plan ends, your sites stop collecting: the snippet stays on your pages but records nothing, and messages, personalization, Site chat and push go quiet. Resubscribe and they switch back on by themselves – no reinstall. A site you switched off yourself stays off.
The API
Call methods through the queue, which is safe to use before the script has loaded:
AICMO.push(['method', ...arguments]);
| Method | What it does |
|---|---|
init({ siteId, consent?, nonce? }) | Starts the SDK. Pass consent: 'pending' to wait for a consent banner, or the choice itself when your server knows it – see Consent and privacy. nonce is your page's Content Security Policy nonce, when the script tag itself does not carry it. |
track(eventName, properties) | Sends a custom business event – see below. |
identify(id, { email?, hash? }) | Tells the SDK who the visitor is – your own customer ID, an email, or both. hash is your server's signature – see Signed identities. Sign every call: Site chat shows a customer named without one to your team as not verified. |
trackConversion(type, { value, currency, email }) | Records a conversion with revenue. |
trackPageView() | Manual pageview, for cases the automatic tracking can't see. |
consent({ analytics, marketing, support? }) | The visitor's choice, passed on every page load from your consent banner's record. null when there is no choice on record. support is optional – see Consent and privacy. |
optIn() / optOut() | The original on/off switch – every category, remembered on this device. |
consentStatus() | Returns granted (analytics and marketing), partial (one of them), denied (neither) or pending (no choice yet). Support is not part of it. |
chat(command, …) | Opens and controls Site chat from your own code – see Site chat. |
reset() | Call it on your site's logout: the browser forgets who the person was – the stored identity, its signature, the last value read from your identity cookie and their chat. When someone had been identified, it also gives the browser a fresh visitor ID, starts a new anonymous person in the visitor analytics and clears their inbox messages from the page. |
getVariant(testId) | The version of a site test this visitor sees on this page – control for the Original – or null. |
debug(true) | Logs every site test decision in the browser console: which tests run here, which version, when one applies and is counted. Also init({ …, debug: true }). |
Custom events
Custom events are how your site's own business moments – a deposit, a booking, a quote request – reach the platform:
AICMO.push(['track', 'deposit', { value: 250, currency: 'USD' }]);
Or with zero JavaScript, declaratively on any element:
<button data-aicmo-event="deposit_click" data-aicmo-value="50">Deposit</button>
Two rules to know:
- Event keys must be registered first in Data → Events, and use lowercase letters, numbers, and underscores. Events with unregistered keys are not stored – but the Events tab shows keys it has seen so you can register them with one click.
- In the warehouse the event lands as
sdk_<key>(a registereddepositbecomessdk_deposit), and a journey with the matching custom-event trigger enrolls the person the next time the engine polls – within about a minute.
You can also define no-code capture rules in Data → Events: a CSS selector or URL match that fires an event without touching your site's code, reading the value from the page or a cookie.
You can also ask the chat: describe the moments you want to measure and it proposes the keys, registers them here, and hands you the snippet for each – see Chat → Your website's events.
Identifying people
Anonymous visitors get a random visitor ID. The moment you know who they are, tell the SDK – with the identifier you key customers on, signed by your server (see Signed identities):
// your own customer ID
AICMO.push(['identify', 'player-48213', { hash: SIGNATURE }]);
// or their email
AICMO.push(['identify', 'jane@acme.com', { hash: SIGNATURE }]);
// both, when you have both
AICMO.push(['identify', 'player-48213', { email: 'jane@acme.com', hash: SIGNATURE }]);
Sign every identify() call. Your warehouse and journeys take an
unsigned one too, but Site chat needs the signature to know who is
chatting, and personal content – person-targeted website messages, the
inbox, personalization – can be set to require it. The identity cookie
below is never signed, so it does not replace a signed identify() for
Site chat.
Pick the one the rest of your data carries. If your CSVs, database pull
or API calls key people on your own ID, identify with that ID and the
website joins the same record; if email is what you have everywhere, use
email. Pass both when both are known and they resolve to one person – the
warehouse keeps every identifier it has seen for someone alongside the
others. Anything with an @ is read as an email, anything else as your
ID.
Identification is what connects website behavior to a real customer:
their events join their profile, journeys can enroll them, and
person-targeted website messages can reach them. If your site already
sets a login cookie, configure it as the identity cookie in Data →
Events and the SDK identifies people automatically – no code change.
Identities read from the identity cookie are not signed, so Site chat shows
those customers to your team as not verified (as anonymous with Require
signed identities on), and personal content set to require signed
identities does not reach them; to have their chats verified, also call
identify() with { hash } from your page.
Identified: a sign-in or a sign-up
Call identify() on every page where the visitor is signed in. That is
the normal install, and it is what keeps their contact, their consent and
the link between this browser and the person up to date. The
Identified event in your warehouse, the one a journey can start on,
is recorded once, when your site newly names them (they sign in, or
sign up and are signed in), and not again on each page:
- the first time this browser names them, or names someone else;
- when they come back signed in after a page where your site named nobody (they were signed out in this browser);
- after
AICMO.reset(); - when your site names them for the first time with a second identifier (their customer ID as well as their email);
- when they arrive signed in from a new Google ad click, so the click is kept with the person.
AICMO.reset() on your logout is still the clean signal: it tells the
SDK at once that the person left, and the next sign-in is always
recorded. Without it the SDK reads a sign-out from the pages that follow:
a page counts as signed out once it has loaded and nobody has been named
on it for 5 seconds, or when it is left without anyone named. A site that
calls identify() only at sign-in has every call recorded, as before.
On a single-page site a reload that names the visitor is not a sign-in,
and neither is a call your site makes again later in the visit (many
sites call identify() whenever they read the account anew, after a
saved profile or a payment). A sign-out and sign-in there without a
reload is recorded when:
- the visitor fills in a password field before your site names them again (the SDK looks only at the field's type, never at what is typed);
- or your site calls
identify()as it opens every page, and then opens one without it.
A sign-in with no reload, no password field and no AICMO.reset() (a
code by text message, a passkey) cannot be told apart from those repeat
calls. Call AICMO.reset() on logout to have it recorded.
Which of the two it was. Your site calls identify() when someone
signs in and when someone signs up, and the call does not say which. So
each recorded Identified event carries how your brand knew the person at
that moment, as the property identified_as:
identified_as | Means | In event lists |
|---|---|---|
known | Your brand already had a contact with that e-mail or customer ID: a sign-in | Signed in on your site |
new | It had none: a sign-up | Signed up on your site (new to the brand) |
typed | Your site named nobody: the visitor typed an address into one of your website messages | Neither of the two |
Signed in or signed up on your site (either one) is every Identified event, whatever it carries. Journeys, audiences and goals pick these lines from the event list – see Signed in and signed up.
"New" is about your brand's contacts, not about the accounts on your
site: someone who registered before your brand's data reached The AI CMO
is a sign-up the first time they sign in, and someone already in your
contacts is a sign-in when they register. When you need the registration
itself, send it as a conversion (trackConversion('signup', …), see
Revenue). Events recorded before 11 Nov 2026 carry no
identified_as, and neither does an event that could not be checked in
time; they count only as either one.
Signed identities
Your site key is in your page's HTML, so anyone can claim to be anyone. Where something is meant for one person – a person-targeted website message, their inbox, personalization by audience, their Site chat conversation – the identity can be signed: your server computes an HMAC-SHA256, as hex, of the person's e-mail or your own customer ID, in lower case, with the site's identity secret, and the page passes it along:
AICMO.push(['identify', 'jane@acme.com', { hash: SIGNATURE }]);
E-mails and customer IDs are compared in lower case, so a customer ID must belong to one person whatever its letter case – your customer number, never a username the customer chose.
The secret is under Identity verification on this page – Reveal or Copy, one per site – and never belongs in the browser. With Require signed identities on, an identity without a valid signature gets only what every visitor gets; anonymous visitors are unaffected. Site chat always needs the signature before it attaches a conversation to a customer's record. A customer named without a valid signature shows to your team as not verified – never with their record, their History or their chat on other devices – and, with Require signed identities on, is ignored. A customer who logs in during a chat they wrote in within the last hour is attached to it within seconds, on the chat's next check. A second, chat-only signature lets a signed-in customer's chat follow them to another device and lists their earlier conversations under History – see Site chat → Their chat on every device. The Site chat studio's Identity tab has the same secret and switch, and says how the site's logged-in customers arrive – signed, unsigned, or with a signature that does not match.
Rotate gives a site a new secret. The current one keeps working for 7 days, so your server can switch first; the card says until when. After that, anyone your server still signs with the old secret counts as not signed in. Only if the secret leaked, Rotate and stop it now stops the old one at once. Only an administrator of the brand the site belongs to can see and rotate its secret or switch Require signed identities – its creator, an administrator of your organisation, or a teammate who can edit the brand, never one who can only view it – and each reveal, rotation and change of the requirement is listed in the admin portal's Audit Logs.
From version 1.29 of the script, the requests that fetch a person's website messages, inbox and personalization carry the e-mail, customer ID, signature and visitor ID in the body of the request, never in its address – so they do not end up in access logs, proxies or the browser's history. Every site loads the newest script from the same address, so there is nothing to change on yours.
Revenue
Send revenue either through a conversion or on a custom event, with whatever else you know at that moment:
AICMO.push(['trackConversion', 'signup', {
value: 49, currency: 'EUR',
external_id: 'player-48213', // or email: 'jane@acme.com'
hash: SIGNATURE, // your server's signature of that identifier
channel: 'affiliate', // your own fields ride along
affiliate_id: 'aff-771', btag: 'b_771_oct', promo_code: 'WELCOME50',
plan: 'pro', country: 'CZ',
}]);
AICMO.push(['track', 'deposit', { value: 250, currency: 'USD', method: 'card' }]);
Once you have called identify, every conversion and event carries that
identity by itself – the email or external_id on a conversion is
only for the moment you learn it there, such as a signup form.
Your own fields. Anything beyond value, currency and the
identifier is kept on the event in your warehouse as its properties – the
marketing channel a registration came through, an affiliate or promo code,
the plan, the market. Up to 20 fields per event; text, numbers and
true/false (text is clipped at 200 characters, nested objects are dropped).
Where the visitor came from – tagged links, tracked links, ad click IDs –
is recorded on every event by itself; pass your own channel field for what
the visitor told you or your system knows.
Those fields then do work. An audience can be "everyone who signed up
where channel is affiliate" (Customers → Audiences → From event → Where
the event has); a journey's On event trigger, and a Wait for event
step, can open only when a field has a value; the customer's timeline
shows each field on the event; and a message in that journey can use it
as {{p.channel}}.
The value becomes the event's amount in your warehouse, and feeds
journey goals, revenue reporting, and What's Working.
How a person registered. When a conversion is the one you marked
Sign-up / registration under Data → Events → Conversions, three of its
fields can also become the person's registration record, the source that
stays with them for affiliate and channel credit: affiliate_id, btag (the
affiliate's tag) and promo_code. Anyone can send anything to a page's
script, so these count only when the conversion is signed – hash on the
conversion, or the signature you last passed to identify in that browser, made over
the conversion's e-mail (or, without one, its customer ID; see Signed
identities). An unsigned value stays on the event as one
of your own fields and never becomes the registration record. A value your
own system sends – a database import's mapped column, or the registration
event your server sends through the API – always takes its place.
Registrations are recorded every 10 minutes. Data → Events → Registration records says how that is going for the brand: what to pick before anything is recorded, what had to be left out, and when the recording keeps failing. If it fails three times in a row, the brand's owner is told once in the notification bell, and the note clears when it works again. Nothing already recorded is lost; sign-ups from that time are recorded once it works.
Website messages
When a journey publishes a website message, the SDK renders it on your site – as a banner, card, or modal – styled to the message, isolated from your page's CSS, and shown at most once per day per message. Person-targeted messages appear only to the identified person they were written for. Impressions, clicks, and dismissals are tracked automatically and feed the journey's performance numbers.
The browser remembers who was identified until your site calls
AICMO.reset(), so without that call a person's message can still show
after they sign out. If your site does not call it, add the condition
The visitor is signed in to the journey's Website message step: the
message, as a popup and in the inbox, then shows only on pages where your
site has named the visitor, and appears as soon as it does. See
The Website message step.
The inbox
Messages can persist in an on-site inbox instead of – or alongside – the one-shot popup. When a visitor has inbox messages, the SDK shows a small launcher in the corner with an unread badge; opening it lists their messages, newest first, and marks them read. Visitors with no messages never see the launcher at all. With Site chat on for the visitor, the messages sit in the chat panel's Inbox tab instead, and one launcher carries both.
Three things put messages there: the journey Website step (choose "Popup + inbox" or "Inbox only" on the step), promos – when a promo with a customer message is credited to someone, that message lands in their inbox automatically, with its terms attached – and the Inbox page (sidebar), where you manage the whole channel.
Managing the inbox
On the Inbox page every message shows opens, clicks and click-through rate, counted per person rather than per page load, next to who it targets, where it came from, and its state – Live, Scheduled, Draft or Ended. You can compose a new message, save it as a draft, schedule it to appear from a date and time, pin it to the top of the panel, edit or duplicate it, end it early, or delete it. A message leaves the inbox on its own when the period you chose runs out.
Who a message goes to: every visitor, one of your saved audiences, one person by email, or one person by your own customer or player id – useful when people sign in with an account number rather than an email address. Person-targeted messages are checked against your suppression lists before they send, and audience and site-wide messages are checked again for each reader, so someone who has opted out or self-excluded sees no marketing. Messages marked as Service – an account, payment or security notice – still reach them, and are shown first in their inbox. Anyone on a blacklist set to "Blocks everything" sees nothing at all.
What a message can contain
Beyond a headline, message and image:
- Up to three buttons, each with its own link and treatment – solid, outline, or a plain link. A button with no link simply acknowledges the message and settles the row, which is what you want for "Got it". Each button is tracked separately, so you can see whether people clicked "Claim bonus" or "See terms".
- A code to copy – shown as a tap-to-copy chip, for a bonus or discount code.
- A label above the headline – a short word like BONUS in your accent colour.
- The deadline, shown as "Ends in 2 days" and read from when the message actually expires, so the card and the truth can never disagree.
- Terms, as text or a link.
How a message looks
The Design section sets the defaults for the whole site – what a card looks like (layout, image shape, button treatment) and what the panel looks like (accent, position, launcher, font, text size, corners, language, title). A sample card beside the controls shows the defaults as you change them.
Each message can then override any of it in its own Design tab: layout, image shape, its own accent, background and text colours, and an accent edge for something important. Anything you leave alone follows the site-wide defaults, so a message only looks different where you meant it to. Where a card carries two buttons, the second one steps down a level so two solid buttons never compete. The preview beside the form is rendered by the same code your visitors run, so what you see is what they get.
Messages can also be translated. The panel itself already speaks ten languages; the Translations tab translates the message inside it – label, headline, body and every button label – and a reader whose language you have not translated sees your original copy.
The Inbox page also documents the two public endpoints for rendering the same inbox natively inside your own logged-in UI instead of the SDK widget.
Site chat
The same script can put a chat on your site: visitors write to your team from any page, and you answer in Helpdesk. Switch it Off, Test or Live in the Site chat row on the Website SDK page, and design it under Design. With Site chat on, your inbox messages move into the chat panel's Inbox tab – one launcher for both. Everything about it – the test link, the studio, phones, replies to visitors who left, the photos and PDFs visitors may attach, signed-in customers, their chat on every device and their History of earlier conversations, consent and the code to open it – is in Site chat.
Personalization
The SDK can change what your site says per visitor. Mark an element with
data-aicmo-slot="hero-title" (or give a CSS selector on the rule), then
create rules under Audience → Audiences → Personalization: what to show,
and who sees it – everyone, or one of your saved audiences.
Higher-priority rules win; identified visitors on your exclusion lists
are never personalized. Variants are plain text by default; HTML variants
exist behind a per-site switch you have to turn on deliberately.
Rules can target devices – all, mobile (phones and tablets), or desktop – so the shorter headline shows only where screens are small.
Rules apply on page load and on navigation in single-page apps. Applied
elements carry a data-aicmo-personalized attribute so your team can see
what changed and why.
Each rule reports how often it applied and, for identified visitors, the revenue those people generated after first seeing it – the rule's row under Personalization reads both, so a rule is never a guess.
Testing versions
Rules show one version per audience. To test versions against each other – a headline, a button, a whole section – make a site test on Experiments (New site test) and build the versions on your site with the Chrome extension's site editor. Site tests count every visitor who is shown them, signed in or not, and say which version earns more; see Experiments.
Site tests
Site tests – A/B, multivariate and site changes, built
in the Chrome extension's site editor – run in the SDK. There is nothing
more to install: a site with the SDK can be tested. The code that runs tests
is a second file, experiments.js, which the SDK loads by itself from the
same address as tracker.js – only on a site that has tests (running,
paused or a shipped winner). A site without tests downloads nothing more
than tracker.js.
How a visitor meets a test
- Published versions only. A draft never reaches a visitor (except through your own preview link). The SDK keeps the site's published tests in the browser for up to 24 hours, so on the next page it starts on them at once, and it checks on every page view that they are still current. When you publish, pause or stop a test, visitors pick it up on their next page view. A visitor back after more than ten minutes sees no test until the SDK has confirmed it still runs. (On a site that had no tests running, a first test can take about five minutes to reach returning visitors.)
- Paused means nothing new. A paused test shows your page as it is to everyone and counts no new visitors, but the visitors it already counted keep counting their goals, so a pause does not cut their conversions out of the results. Resume picks up where it left off.
- One version per browser, for the life of the test. Which version a
visitor sees follows a random site test ID kept in their browser, never
their e-mail address or login. Signing in,
identify()and signing out withAICMO.reset()do not move them to another version. A browser that does not keep it (storage blocked) sees your page as it is and is not counted. - The Original is your page as it is. A visitor in the Original gets no change at all, not even a marker on an element.
- Counted once, when the test applies. A visitor is counted the first time the test applies on a page they view: the page matches the test's pages, and an element the test changes, in any of its versions, is on the page. The rule is the same for every version, the Original included, so the versions are compared on equal terms. A visit where the element never appears (a dialog nobody opened) is not counted.
- Goals count after that, for counted visitors only: a click on the
goal's element (once per page view), reaching the goal's page, an
AICMO.trackevent of the goal's name, and the value ofAICMO.trackConversion(itsvalue, elserevenue, elseamount) for revenue goals. - Anonymous and signed-in visitors alike. Tests count browsers, so visitors who never sign in count too. A test for one of your audiences reaches identified visitors in that audience (signed ones, when the site requires signed identities). Identified visitors inside a journey that holds out a control group see your page as it is in measured tests and are not counted, so neither the journey's uplift nor the test is muddied.
Changes that survive your site's code
- Text is changed inside the element. A headline with a link or an icon in it keeps the link and the icon; only the words change.
- Hiding and styling are kept in a stylesheet, so React, Vue or Angular re-rendering the element's classes or inline style does not undo them. If your app puts the original text back, the change is applied again (up to three times a page; after that your app's version stays).
- Elements that render late are changed when they appear, up to 10 seconds after the page loads or after a navigation.
- Nothing is overwritten blindly. A change applies only where the page still shows what you saw in the editor: if your site's own text or the element has changed since, the test leaves it alone and the test's delivery health in Experiments reports it.
- Single-page apps are followed: on every navigation, tests for the new page apply and tests that no longer match go back.
Avoiding flicker
From a visitor's second page on, the SDK hides the elements the site's
tests change the moment it starts, before experiments.js has arrived
(usually from the browser's cache), and shows each one as its version is in
place – never longer than 1.5 seconds, even when experiments.js is slow or
blocked, and the same way for every version, the Original included. An
element a test changes on another page of your site can be hidden for that
moment too, until experiments.js sees the test is not for this page.
On a visitor's first page the SDK has to ask which tests run, so your
original content can show for a moment before it changes. If a test
changes something visible as the page opens, add this to your page's
<head>, before your own styles, with your site key in place of
lpo_your_site_id:
<!-- anti-flicker -->
<style>.aicmo-xwait body{opacity:0!important}</style>
<script>(function(h,k){try{if(localStorage.getItem(k)==='0')return}catch(e){}h.classList.add('aicmo-xwait');setTimeout(function(){h.classList.remove('aicmo-xwait')},1500)})(document.documentElement,'aicmo_xa_lpo_your_site_id')</script>
It hides the page until the SDK knows the tests – usually a fraction of a second, and never more than 1.5 seconds, even when the SDK is blocked or slow. Once the SDK has seen that the site runs no tests, the snippet stops hiding pages. On a site with a Content Security Policy, give the style and script your nonce too – see Content Security Policy.
Content Security Policy
Site tests need nothing new in a policy that already lets tracker.js run:
experiments.js comes from the same address
(https://theaicmo.com/sdk/v1/experiments.js), and the tests talk only to the
address the SDK already uses.
- Allowing by address. If your
script-srcallowshttps://theaicmo.com(orhttps://theaicmo.com/sdk/v1/),experiments.jsis allowed with it. If it names the file itself (https://theaicmo.com/sdk/v1/tracker.js), addhttps://theaicmo.com/sdk/v1/experiments.js. - With a nonce. The SDK puts your page's nonce on the
experiments.jstag and on its own stylesheets for tests (the anti-flicker hold, hidden and restyled elements). It reads the nonce from thetracker.jsscript tag, or pass it toinit:
AICMO.push(['init', { siteId: 'lpo_your_site_id', nonce: 'your-page-nonce' }]);
connect-srcmust allowhttps://theaicmo.com, as for the rest of the SDK.
If the policy blocks experiments.js, your page stays exactly as it is:
nothing is hidden for longer than a moment, no test applies, nobody is
counted, and the browser's console names the blocked address.
Previewing a test
Copy preview link, in the app or in the editor, gives your page's
address with ?aicmo_qa=… (and &aicmo_force=… for the version you
picked). Opened in a browser, the SDK shows that test – a draft too – in
that version on the pages the test is for, whatever its hosts, devices,
audience, schedule or traffic share, and a small badge in the bottom-left
corner names the test, switches between its versions and has Exit
preview.
The preview stays on in that tab while you browse, until you exit or open
a page with ?aicmo_qa=off. Nobody is counted and no goal fires while
previewing. Preview links work for 24 hours, and like everything else in
this section they need marketing consent on the page. When your consent
banner gives it a few seconds after the page opens, the preview starts
then, and stays on for the tab.
For your developers
// The version this visitor sees: 'control' (the Original), 'b', 'c' …,
// or for a multivariate test the combination, such as 'hero:b|cta:control'.
AICMO.getVariant('TEST_ID');
// Told when a test applies on the page (detail: { id, arm }).
document.addEventListener('aicmo:experiment', function (e) {
if (e.detail.id === 'TEST_ID' && e.detail.arm === 'b') { /* your own code for version B */ }
});
getVariant answers null until the SDK has decided on this page (it
decides once experiments.js is in), so code that runs as the page loads
is best put in the aicmo:experiment listener.
The test ID is in the test's address on Experiments (?id=…). When the
page has Google Tag Manager's dataLayer, each measured test that applies
pushes { event: 'aicmo_experiment', aicmo_experiment_id, aicmo_arm } –
never during a preview. AICMO.debug(true) (or init({ …, debug: true }))
logs every decision in the console on a page where tests run, including
those made before you called it. While the extension's site editor is open
in a tab, the SDK loads, applies and counts no tests there, so what you edit
is your page as it is.
Consent
Site tests belong to the marketing category. They start when the page allows marketing as it loads – a choice passed with the snippet, or reported by your banner in the page's first moments. A visitor who accepts later on the page sees tests from their next page, so the page never changes under their eyes. A preview link starts as soon as marketing is allowed, whenever that is: it is you looking at your own test, and nothing is counted. Withdrawing marketing takes every change back at once and deletes the site test ID, the cached tests, the record of tests the browser was counted in and the anti-flicker hint.
Web push notifications
Turn browsers into a push channel – no third-party push provider needed. Browser subscriptions are off by default: nothing is offered or collected from visitors until you switch them on for the site (Website SDK page → Web push notifications). Once on, two steps:
-
Host a one-line service worker at your site root, saved as
/aicmo-sw.js(browsers require this file to live on your own domain):jsimportScripts('https://theaicmo.com/sdk/v1/push-sw.js'); -
Call
AICMO.registerPush()from your own button – for example an "enable notifications" toggle in your account area. Browsers punish permission prompts the visitor didn't ask for, so the SDK never prompts on its own.
That's it. Subscribed browsers become reachable by the Push step in
Journeys. Subscriptions are matched to the person once you identify
them – someone who subscribes anonymously and logs in later becomes
addressable automatically. AICMO.unregisterPush() removes this
browser's subscription.
This is mobile push without an app: on Android phones, notifications arrive like any app's – even with the browser closed. On iPhone they arrive once the visitor has added your site to their home screen (Apple requires your site to ship a web app manifest for that). Desktop Chrome, Edge, and Firefox work everywhere. Blacklists and self-exclusion are enforced before every send.
Mobile apps (React Native)
Your React Native app gets the same three things through
@aicmo/react-native – no dependencies, and no third-party push
provider:
- Events and identity –
identify,track, andtrackConversionland in your warehouse exactly like the website SDK's. - Push, delivered directly – upload your Firebase service account
on the Website SDK page (verified live, stored encrypted) and The AI
CMO sends notifications straight through your own Firebase project:
Android natively, iOS via Firebase's APNs integration. Your app
passes its FCM token with
registerPushToken, and the Push step in Journeys reaches the device – matched to the person afteridentify.
The package README walks through setup for bare React Native and Expo. Blacklists and self-exclusion are enforced before every send, on this route like every other.
Survey pages
Your hosted survey pages can carry your site's SDK too: in a survey's
Fill page & branding → Tracking section, pick the site and survey
visits land in your analytics, with a survey_completed event fired on
submit. GA4 and Meta Pixel IDs are supported there as well – IDs only,
never scripts. Owner previews are never tracked.
Consent and privacy
If your site asks visitors for cookie consent, the SDK follows the answer: it runs only what the visitor allowed, runs nothing before they choose, and deletes what it stored when a choice is withdrawn or expires.
Three categories
| Category | What it turns on |
|---|---|
| Analytics | Page views, visitors and sessions, where visits come from (the referring site and UTM parameters), scroll depth, clicks on calls to action, forms started and abandoned and their timing (never what is typed), page performance – the visitor charts. Anonymous: analytics alone never names the person. Without marketing, ad click IDs are left out of every event and page address sent to the visitor analytics. |
| Marketing | Identifying people, campaign attribution (first and last touch, UTM parameters, ad click IDs such as gclid and fbclid), conversions and custom events in your warehouse, website messages, the inbox, personalization, site tests, web push. |
| Support | Site chat and nothing else: the visitor's messages, an e-mail address they give for replies, and the page path, device type, language and time zone of the conversation. No tracking, no identify() values, nothing for journeys or your warehouse – a signed chat identity (AICMO.chat('identify', …)) can still tell the chat who a logged-in customer is. An unsigned one is not used: a claim needs marketing. Optional – not stated, it follows marketing. |
With analytics and marketing allowed, everything on this page works as described, Site chat included. With neither, the SDK tracks nothing, identifies nobody and loads nothing more; it keeps only the choice itself, and a withdrawal by someone it already knew is noted in their consent history (see below). Site chat then runs only if your site allows support.
With analytics alone, identify does nothing, and an email or customer
ID you put on an event is left out. With marketing alone, conversions,
identity, messages and attribution work, and the visitor is not counted
in page views or sessions.
Support is for sites that want to offer the chat to visitors who have not allowed marketing – a player who declined marketing but needs help, for instance. Pass it with the others, or on its own:
AICMO.push(['consent', { analytics: false, marketing: false, support: true }]);
AICMO.push(['consent', { support: true }]);
Support merges with the other two. A consent call that leaves support
out keeps what the page said about it earlier; a call that carries only
support leaves analytics and marketing exactly as they were – a choice
still pending stays pending. Not stated at all, support follows marketing –
or, on a site without consent mode, the chat works for everyone who has not
turned the SDK off with optOut(). consent(null) clears support along
with the rest, so a page that passes null and still offers the chat passes
{ support: true } after it. Which of your banner's categories gives
support is your decision.
Passing the choice
Start the SDK in consent mode and pass the visitor's choice with
consent on every page load:
AICMO.push(['init', { siteId: 'lpo_your_site_id', consent: 'pending' }]);
AICMO.push(['consent', { analytics: true, marketing: false }]);
Every page load, because your banner's record is the source of truth:
the SDK never runs a page on a choice it remembers from an earlier one.
Also call it when the visitor changes their choice in your banner, so
the change applies without a reload. Pass null when there is no choice
on record – a first visit, or a choice that expired. The values are
true or false; anything else counts as not allowed.
Until the choice arrives the SDK waits, and the calls your own code makes
– track, identify, trackConversion – wait with it. Once it arrives
they run as far as the choice allows; after a refusal they are dropped.
You do not need to wrap them in consent checks yourself.
Your banner keeps the choice in a cookie
Read the cookie and pass it. Here the banner stores three digits –
necessary, analytics, marketing – so 110 means analytics without
marketing:
<!-- The AI CMO -->
<script async src="https://theaicmo.com/sdk/v1/tracker.js"></script>
<script>
window.AICMO = window.AICMO || [];
AICMO.push(['init', { siteId: 'lpo_your_site_id', consent: 'pending' }]);
function aicmoConsent() {
var m = document.cookie.match(/(?:^|;\s*)site_consent=([01]{3})/);
var v = m ? m[1] : null;
AICMO.push(['consent', v ? { analytics: v[1] === '1', marketing: v[2] === '1' } : null]);
}
aicmoConsent();
</script>
Then call aicmoConsent() once more in your banner's save handler,
after it has written the cookie. Change the cookie name and the digit
positions to match your banner.
The cookie is HttpOnly
A page cannot read an HttpOnly cookie, but your server can. Have the
server write the choice into init on every page it renders – null
when there is no cookie:
<script>
window.AICMO = window.AICMO || [];
AICMO.push(['init', { siteId: 'lpo_your_site_id', consent: { analytics: true, marketing: false } }]);
</script>
When the visitor changes their choice on the page, your banner's code
knows the new choice – pass it with
AICMO.push(['consent', { analytics: …, marketing: … }]). From the next
page on, the server renders it.
In a single-page app the choice holds for the whole visit; you pass it again only when it changes.
When the choice expires or is withdrawn
- The SDK keeps nothing longer than your banner does. When your
consent cookie expires or is deleted, your page passes
null(or the server renders it), and on that page load the SDK stops and deletes everything it stored on the device. A choice that no longer allows a category deletes that category's entries the same way. - Withdrawing on the page takes effect at once. The withdrawn category stops sending immediately – page views, clicks, forms and leaving the page included – and its entries are deleted. Turning analytics back on after withdrawing it takes effect from the next page load.
- Marketing withdrawn, analytics kept. Identifying, attribution and ad
click IDs stop at once. A visitor who was identified earlier on the same
page stays identified in the visitor analytics for the rest of that page
– in a single-page app, the rest of the visit – and what they do in that
time reaches your warehouse as their
web_events, like any identified visitor's. From the next page load the SDK no longer names them. - Every change is recorded. A new or changed choice appears in the
person's consent history as web tracking – "granted" when it allows
both categories, "granted (analytics only)" or "granted (marketing
only)" when it allows one, "withdrawn" when it allows none. You see it
on the person's Compliance and Activity tabs (open the person
from Customers) and in the Consent lookup under Audiences. Passing
the same choice on every page does not add rows, and an expired choice
is not recorded as a withdrawal. A withdrawal is recorded under the
person the SDK knew on that page even when your consent tool deletes the
SDK's entries before it passes the choice on, as some do for a refused
category. Support is kept with the record but never decides it: granted
or withdrawn follows analytics and marketing alone, and a call that
carries only
supportadds no row.
The original on/off switch
optIn() and optOut() still work, for banners with a single yes or
no. optIn() allows every category – analytics, marketing and support –
and is remembered on this device for later visits. optOut() refuses all
three, deletes what the SDK stored, Site chat's entries included, and is
remembered, so the SDK stays silent on later visits. If your banner has
categories, or its choice expires, use consent instead.
What the SDK keeps in the browser
The SDK sets no cookies. What it keeps lives in your site's
localStorage (and, for the entries marked so, sessionStorage, which
ends with the browser tab). <site> is your site key.
| Name | Category | What it holds |
|---|---|---|
aicmo_consent_<site> | Necessary | The last choice passed – analytics, marketing, and support when a page stated it – or the optIn/optOut decision; what keeps the SDK silent after a refusal |
aicmo_visitor_<site> | Analytics or marketing | A random 12-character visitor ID; replaced by a fresh one when AICMO.reset() signs out someone who had been identified |
ph_aicmo_ph… (also in sessionStorage) | Analytics | The visitor analytics layer: a random ID, replaced by the ID you passed to identify when a visitor who allowed marketing is identified; the session; the first page address and referrer, with their UTM parameters; cached settings. When it starts on a page without marketing allowed, ad click IDs are masked in what it stores |
aicmo_grp_<site> | Analytics | The analytics session in which the site's domain and name were last sent, so they go once a session |
__ph_opt_in_out_<key> | Analytics | Left by a withdrawal on a page where analytics was running; removed on the next page load |
aicmo_ph_off_<site> | Analytics | Set only when visitor analytics is off for this site (the site is paused, or this visitor is outside its sampling share), so the next page waits for the setting instead of starting analytics; removed once analytics is on again |
aicmo_touch_<site> | Marketing | First and last campaign arrival: source, medium, campaign, referrer, landing page, time |
aicmo_link_attr_<site> | Marketing | The last tracked link or UTM campaign |
aicmo_click_ids_<site> | Marketing | Ad click IDs (gclid, gbraid, wbraid, fbclid, ttclid, msclkid) with their time; sent with events for 90 days. The visit history is sent from what the page already holds and adds no key of its own |
aicmo_identity_<site>, aicmo_extid_<site>, aicmo_idsig_<site> | Marketing | The email, your customer ID and the identity signature passed to identify; also deleted by AICMO.reset() |
aicmo_autoid_<site> | Marketing | The last value read from your identity cookie, so a repeat page load does not identify again; also deleted by AICMO.reset() |
aicmo_idann_<site>, aicmo_idout_<site> | Marketing | The last sign-in recorded for this browser (its event ID, whether the platform answered, and the time of the newest Google ad click it carried; nobody is named in it), and a mark that a page was seen with nobody signed in, so the next identify is recorded as a sign-in; also deleted by AICMO.reset() |
aicmo_msg_<message> | Marketing | Whether a website message was seen or dismissed, for its once-a-day limit |
aicmo_pz_exp_<rule> | Marketing | A personalization rule already reported as seen by this person |
aicmo_xu_<site> | Marketing | A random site test ID: which version of a site test this browser sees. Made from the visitor ID the first time a test needs it; kept by AICMO.reset(), so a visitor's version does not change at sign-out |
aicmo_xm_<site> | Marketing | The site's published site tests and the elements they change, kept up to 24 hours so the next page starts on them at once (and keeps those elements hidden until their version is in place) |
aicmo_xe_<site> | Marketing | The site tests this browser was already counted in, and the version of each test that counted it |
aicmo_xa_<site> | Marketing | Written only where the anti-flicker snippet is installed: 0 when the site runs no tests, so the snippet does not hide the next page (1 once it runs tests again) |
aicmo_xd_<site> (sessionStorage) | Marketing | For an identified visitor: whether they are in the audience of an audience-targeted test, and whether a journey's control group leaves them out of tests; kept 10 minutes, and deleted by AICMO.reset() |
aicmo_qa_<site> (sessionStorage) | Marketing | This tab is previewing a site test: the preview link and the version picked |
aicmo_support_conv_<site> | Marketing | Left by SDK versions before 1.28 (the old support tab); no longer written, and deleted with the marketing entries |
aicmo_push_<site> | Marketing | This browser subscribed to web push |
aicmo_arrival_<site> (sessionStorage) | Marketing | This tab arrived from a campaign link |
aicmo_chat_<site> | Support | Site chat: a random key for this browser's conversation, the conversation, a short fingerprint of a signed-in identity, when the newest message arrived, whether it was resolved, the unread count. Also deleted 30 days after the last message, and by AICMO.reset() or AICMO.chat('reset') |
aicmo_chat_ui_<site> (sessionStorage) | Support | Site chat in this tab: the panel open or closed, an unsent draft, messages not yet confirmed as sent (with the names of the files attached to them), previews dismissed, the reply address given here, the unread count. Also deleted by AICMO.reset() or AICMO.chat('reset') |
aicmo_chat_test_<site> (sessionStorage) | Support | This tab opened Site chat's test link |
Browser storage has no expiry date of its own. Each entry is kept while its category is allowed and deleted on the first page load where it no longer is – so with the choice passed on every page, nothing outlives your banner's record. Site chat's entries are deleted only when support stops being allowed – never with the marketing entries.
The only cookies the SDK reads are the ones you configure in Data → Events for identity or value capture, and it reads them only with marketing allowed.
Do Not Track
Do Not Track is respected by default for the analytics category: a
browser sending DNT is not counted in page views or sessions. A visitor
who accepts analytics on your own consent banner (consent mode, or
optIn()) is counted anyway – their choice on your site wins over the
browser-wide signal. Without a banner, DNT stands; respectDNT: false in
init stops the SDK from reading it at all. It never stops the marketing
category – consent does.