Stream anonymous behavior and predicted intent into any application. While the visitor is still on the page.
Designed to complement your existing stack, not replace it.
engine.on('behavior.signal', s => { // s.engagement, s.intent, s.next… });
Recognize the visitor anonymously. Predict what they'll do next. Identify and enrich when you want to. All from one SDK, streamed in real time.
Recognize and understand every visitor through anonymous micro-behavior. Scroll cadence, cursor rhythm, hesitation. The signal between the events your stack already captures.
SQID's contextual engine matches each visitor against tens of millions of anonymous sessions and returns the three most likely next moves, live.
Anonymous by default. When you want, resolve identity and enrich with your CRM, identity graphs, or any data source. Either SQID does it, or your server does. The stream stays the same.
Analytics shows you what happened. Identity tools show you who someone might be. Neither captures what visitors are doing between the events. SQID does. Anonymously, continuously, at the first mile.
Same events. Same models. Higher-fidelity signal underneath.
SQID's domain-tuned AI matches each visitor's behavior against tens of millions of anonymous sessions and returns the three most likely next moves. Live. As they happen.
Trigger the right offer at the right moment. Surface a newsletter prompt to readers about to leave. Hold back the paywall for someone who's about to subscribe anyway.
Route high-intent anonymous visitors to a rep before they bounce. Let your SDRs work on the leads most likely to convert in the next ten minutes.
Adapt the page in real time. Show the case study someone like this visitor responds to. Soften the form for a hesitator. Skip steps for a decisive one.
A predictive engine, trained on behavior. Anonymous by design.
Most visitors stay anonymous. SQID still recognizes them by behavior and predicts their intent. When you want to know who someone is, identity resolution is one flag away. SQID can resolve it, your server can, or both. Once identified, enrichment plugs into your CRM, identity graphs, or any data source you already use.
// Your server receives every identified visitor app.post('/visitor_details', async (req, res) => { const visitor = req.body; // { name, email, company, company_role, linkedin_url } // Look up in YOUR database const record = await db.query({ email: visitor.email }); // Send merged data back to the browser res.json({ ...visitor, ...record }); });
Anonymous behavior and intent are the default. Identity is optional. Activation is consent-aware.
SQID captures behavioral signal. Scroll cadence, cursor rhythm, click pattern, hesitation. None of it identifies a person. All of it scores intent. The stream you consume is anonymous unless you ask it not to be.
When identity resolution is enabled, SQID uses opt-in third-party identity graphs already legal in your stack. Every match shows its provenance. You see where a resolution came from before you act on it.
Consent state propagates through the stream. Visitor opt-out is one API call and takes effect in the same session. SQID respects DNT, GPC, and your own consent management platform.
SQID is a pipe, not a database. By default, visitor signal is ephemeral. It exists in the stream long enough for your app to act on it. Storage is opt-in and you control where.
Powerful enough to predict the next move. Defensible enough to ship.
Three patterns, anonymized from the publisher, SaaS, and retail categories. Same playbook: layer SQID's behavioral signal under existing events, and the same models suddenly know what they're looking at.
A subscription site used dwell-style events to measure engagement. The model worked, but couldn't separate engaged readers from background tabs.
SQID's micro-behavior signal layered under the same events. Same instrumentation. Now the engagement model knew which readers were actually reading. Paywall prompts moved to the high-intent moments.
A B2B platform only knew which visitors were high-intent after a form fill. By then, most had bounced.
SQID scored anonymous intent during the browsing phase. The visitor's behavior — slow scroll, cursor on pricing, repeat visit — flagged them as a high-fit account before they ever filled anything out. Sales got the alert while the tab was still open.
A retailer saw cart abandoners show hesitation signals long before the cart event — but the cart event was the earliest moment their stack could act.
SQID flagged hesitating visitors mid-session, before they put anything in a cart. A personalized offer or chat handoff fired in the moment the doubt appeared.
A persistent, bidirectional stream between every browser and your stack. Signal goes in. Predictions, identity, and enrichment come out. Real-time, both directions, always on.
Built on Apache Pulsar. The same distributed messaging infrastructure behind Yahoo, Splunk, and Verizon. Exposed as one SDK and a simple consumer API.
Real examples. Working code. Every recipe is a starting point you can deploy today.
Skip "What's your email?" — the chat widget knows who they are before they type.
engine.on('visitor.identified', event => { const visitor = event.detail; window.Intercom('boot', { app_id: 'YOUR_APP_ID', email: visitor.email, name: visitor.name, company: { name: visitor.company } }); });
Enterprise companies see enterprise pricing. Developers see API features. Managers see analytics.
engine.on('visitor.identified', event => { const visitor = event.detail; if (visitor.company_role?.match(/engineer/i)) highlightFeatures(['API', 'SDK', 'Webhooks']); else if (visitor.company_role?.match(/manager/i)) highlightFeatures(['Analytics', 'SSO', 'Reports']); });
"Before you go, Sarah..." — personalized offers by name, company, and role. Suppress for existing customers.
document.addEventListener('mouseout', e => { if (e.clientY < 0 && visitorData) { showModal({ title: `Before you go, ${visitorData.firstName}...`, message: `Demo for ${visitorData.company_role}s` }); } });
Feed identity into every analytics tool at once. Connect anonymous sessions to known users.
engine.on('visitor.identified', event => { const v = event.detail; gtag('set', 'user_properties', { user_id: v.id, company: v.company }); analytics.identify(v.id, { email: v.email }); mixpanel.identify(v.id); });
From zero to streaming behavior, prediction, and identity.
One script tag in your frontend.
// Add to your page ;(function(squid){ (window.$quid) || (window.$quid = {}); document.head.appendChild((function(s){ s.src='https://app.asksquid.ai/tfs/' +squid+'/sdk'; s.async=1; return s; })(document.createElement('script'))); })('YOUR_SDK_ID');
Get visitor data the moment identity resolves.
const engine = new squid.engine(); engine.on('visitor.identified', event => { const v = event.detail; // v.name, v.email, v.company, // v.company_role, v.linkedin_url });
Identity, behavior, enrichment — streaming to your code. What you build is up to you.
// AI agent context // Website personalization // Sales routing // Embedded analytics // Your idea here
SQID is a horizontal data layer. The verticals that need anonymous, real-time behavioral intelligence the most:
Convert anonymous traffic to qualified leads. Route high-intent visitors to sales before they bounce. Personalize the page based on who's actually evaluating.
Recognize the buyer before the cart event. Predict the purchase moment. Surface the right product, the right offer, at the right hesitation.
Signals over segments. Intent over profiles. Anonymous behavioral targeting that survives cookie deprecation, built for buyers who've moved past demographic boxes.
Time paywalls, newsletter prompts, and subscription offers to real engagement, not pageviews. Higher-fidelity signal feeding the same audience and engagement models you already run.
A visitor lands on pricing for the third time this week. Before they type, your agent already knows they're comparing plans, likely evaluating enterprise, and should offer procurement answers. Context, before the first message.
Embed SQID into your product, or license the dataset behind it. Tens of millions of anonymous behavior signatures. A new primitive to build on.
One script tag. Real-time behavior, identity, and intent streaming into your stack. Ship in a day, scale with your product.
Get your API key →License the behavioral data layer. Anonymous behavior signatures across tens of millions of sessions. The new primitive for adtech, retail intelligence, and audience platforms.
Talk to us →Stop building behavioral signal infrastructure from scratch. One SDK gives your product real-time behavior, prediction, and identity. Focus on what makes your app unique.
No credit card. No sales call.