Build on real-time
visitor intelligence.

One SDK turns every browser into a live edge — identity-aware, bidirectional, always connected to your backend. Not an API call. A runtime.

const engine = new squid.engine({ sp: 'https://my-api.com' });

engine.on('visitor.identified', event => {
  const visitor = event.detail;
  // name, email, company, role — streamed live
  // enriched by YOUR server via the service provider
});
Get your API key Read the docs

Powering real-time experiences for 12M+ visitors/month

Live

This is running on you. Right now.

Our SDK is on this page. Here's what it resolved about your session, and the event stream your app would receive.

Visitor Profile Identified
Company
Industry
Location
Employees
Funding
NameSarah Chen
Role
Engagement
Event Stream Streaming
0mssquid:connected
80msiframe:loaded
120msprofilejar sent for resolution
290msvisitorIDidentity resolved
340msvisitor.identifiedVP Engineering, Plaid
410msvisitor.synchedenrichment complete
450mseventpageview tracked
nowbehavior.scrollhero

Resolved in 340ms. No login. No form. No cookies. This is the same stream your code receives.

Why SQID.dev

Visitor intelligence is hard to build.
It shouldn't be.

Identity resolution, behavioral streaming, real-time enrichment, frontend-backend sync — it's a lot to build from scratch. SQID.dev packages it all into one SDK.

Without SQID.dev
  • Build your own identity resolution
  • Stand up WebSocket infrastructure
  • Wire up enrichment APIs
  • Sync frontend and backend state
  • Maintain it all as you scale
Months of engineering. Not your core product.
With SQID.dev
<script src="sqid.js"></script>
  • Person-level identity — resolved
  • Real-time bidirectional stream — handled
  • Progressive enrichment — built in
  • Frontend + backend sync — automatic
  • Scales with your product
One SDK. Ship in a day.
The visitor runtime

A live edge in every browser.
A unified stream on your backend.

The SDK makes the browser an intelligent endpoint. The runtime keeps everything in sync.

Live Edge — the browser

Identity

Person-level resolution — name, role, company, LinkedIn — resolved client-side. Your frontend knows who the visitor is without asking your server.

340ms avg resolution · US coverage · opt-in data

Behavior

Clicks, scrolls, page views, engagement scoring. Captured and streamed from the browser in real time. Not batched. Not polled.

sub-50ms event delivery · continuous · automatic

External Data

The frontend can reach out to any data source through the runtime. Enrich the visitor session with third-party data without a proxy server.

any API · any service · one integration point

Visitor Runtime — the backend

Unified Stream

Your backend subscribes to one stream and gets everything — identity, behavior, enrichment — as events. Multiple consumers, one source of truth.

pub/sub · fan-out · guaranteed delivery

Enrichment

Company data, funding, headcount, industry, technographics. Progressively resolved and pushed to all consumers as it becomes available.

progressive · self-correcting · session-persistent

Synchronization

Frontend and backend share the same real-time channel. State stays in sync without you building WebSocket infrastructure or polling logic.

bidirectional · persistent · always connected
Service Provider

Your server in the loop.

When SQID.dev identifies a visitor, it can hit YOUR server first. Enrich the profile with your own data — CRM records, subscription status, feature flags — before it reaches the browser. No other identification tool does this.

1
SQID.dev identifies visitor
2
Your server enriches the profile
3
Combined data delivered to browser
service_provider.js
// 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 });
});
Recipes

Copy. Paste. Ship.

Real examples. Working code. Every recipe is a starting point you can deploy today.

Chat integration

Intercom / Drift / Crisp / Zendesk

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 }
  });
});

Pricing personalization

browser + service provider

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']);
});

Exit intent

browser + service provider

"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`
    });
  }
});

Analytics enrichment

GA4 / Segment / Mixpanel / Amplitude / 8 more

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);
});
View all recipes in the playground
Data activation

Get data where you can act on it.

The intelligence already exists — identity graphs, enrichment APIs, your CRM. The problem is getting it to the point of decision in real time. No infrastructure to manage. No data to store. Just a live pipe from source to action.

DATA SOURCES Identity graphs Enrichment APIs Your CRM Your internal APIs POINTS OF ACTION Your frontend Your AI agents Your backend Your sales team SQID.dev Data flows in real time. No storage. No batch jobs. Just a live pipe from source to action.

No data to store

SQID.dev doesn't warehouse your data. It streams it. Identity and enrichment data flows from source to destination in real time — through the runtime, not into a database you have to manage.

No infrastructure to build

WebSocket servers, pub/sub brokers, event pipelines — you'd normally build all of this yourself. One SDK and you get it out of the box. Focus on your product, not your plumbing.

Any source, same stream

Plug in ZoomInfo, Clearbit, Apollo, or your own enrichment. The runtime delivers it all the same way — real-time, bidirectional, to every subscriber simultaneously.

Activate at the point of decision

Data locked in a dashboard doesn't convert. Data in your frontend, your chatbot, your agent — while the visitor is still on the page — does. That's what real-time delivery changes.

Architecture

Not an API. A runtime.

Every other vendor gives you a request/response lookup. We give you a persistent, bidirectional stream.

Traditional approach

Your app → HTTP request → API → JSON → done
  • One direction. One shot.
  • Want an update? Ask again.
  • Frontend and backend disconnected.
  • Identity is a lookup. Right or wrong, once.
  • 200-500ms per request.

SQID.dev

Your app ↔ SQID.dev Runtime ↔ Your backend
  • Persistent. Bidirectional. Always on.
  • Every subscriber gets every event instantly.
  • Frontend and backend synchronized.
  • Identity resolves, enriches, self-corrects.
  • Sub-50ms on open connection.

Built on Apache Pulsar. The same distributed messaging infrastructure behind Yahoo, Splunk, and Verizon. Exposed as one SDK and a simple consumer API.

Get started

Five minutes to real-time visitor intelligence.

From zero to streaming identity, behavior, and enrichment.

01

Add the SDK

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');
02

Listen

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
});
03

Build anything

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
Built for

Teams that build software.

AI agent companies

Your agent is smart. Make it smart about people. Subscribe to the visitor stream — know who your agent is talking to before the first message.

SaaS platforms

Embed visitor intelligence into your product. One SDK. Your customers get identity, behavior, and real-time data without you building it.

Engineering teams

Stop building identity resolution infrastructure. One SDK, one event listener, and your app knows who every visitor is. Ship in a day, not a quarter.

Your product is smart.
Make it smart about people.

Stop building visitor identity infrastructure from scratch. One SDK gives your product real-time intelligence about every visitor — so you can focus on what makes your app unique.

Get your API key Read the docs

Free tier. No credit card. No sales call.