We built the plumbing so you don't have to.

SQID.dev is the developer platform born from what our customers showed us was the most powerful part of what we built.

Where it started

We started with asksquid.ai. The idea was straightforward: website tooling was slow, fragmented, and built for data analysts, not the teams who actually needed to act on the data. So we built a platform that brought everything together. Web analytics. Behavioral heat maps. Engagement and visitor behavior tracking. Person-level identification. All in one place, all in real-time.

To make that work, we had to solve hard infrastructure problems. We needed a persistent connection to the browser, not HTTP polling. We needed a message bus that could handle millions of events without dropping data. We needed identity resolution that could push results back to the frontend in hundreds of milliseconds, not minutes. We needed the frontend and backend to stay in sync without the customer building WebSocket servers.

So we built it. Socket.io for persistent browser connections. Apache Pulsar for distributed messaging. Microservices that scale independently. A single SDK that abstracts all of it into one script tag.

We built serious infrastructure and packaged it as a simple analytics product.

What our customers found

As teams started using asksquid.ai, something unexpected happened. Our most engaged customers were not spending their time in the dashboard looking at heat maps. They were hooking into the underlying infrastructure.

They discovered that the real-time WebSocket connection, the bidirectional data streaming, the ability to push enriched visitor data back to the browser mid-session. That was the valuable part. They started embedding our SDK into their own SaaS products. They plugged it into their AI agents and chatbots so they could greet visitors by name before the first message. They used the Service Provider pattern to merge their CRM data with our identification and deliver personalized experiences in under 400 milliseconds.

No other vendor in the space could do this. Other tools identify a visitor and hand you a JSON blob. Done. Our customers were subscribing to a live stream and building real-time applications on top of it. They were leveraging the most powerful parts of what we built for asksquid.ai. The parts we had simplified for the analytics product were exactly what developers wanted direct access to.

They were not buying visitor identification. They were buying the infrastructure.

Why SQID.dev exists

SQID.dev is the developer platform that exposes that infrastructure directly. Everything that powers asksquid.ai under the hood, the WebSocket connections, the Pulsar message bus, the real-time identity resolution, the Service Provider pattern, is now available as a set of APIs and SDKs that developers can integrate into their own products.

The SDK maintains a persistent connection between the browser and your stack. Identity, behavior, and enrichment data stream through the same channel. Your frontend knows who the visitor is without asking your server. Your backend subscribes to the same event stream. Your AI agents, your chatbots, your personalization engine. They all connect to the same real-time pipe.

Your server stays in the loop. When we identify a visitor, we can hit your endpoint first. You enrich the profile with your own data. The merged result is what the browser receives. No other identification vendor does this.

We are not asking you to replace your analytics stack. We are giving you the infrastructure layer that took us years to build so you can ship visitor intelligence in your product in a day instead of a quarter.

asksquid.ai is the product. SQID.dev is the platform it runs on. Now you can build on it too.

Under the hood

WebSocket connections

Every visitor session opens a persistent, bidirectional Socket.io connection. The browser sends behavioral events up. The server pushes identity, enrichment, and commands down. No HTTP round-trips. No polling. Sub-50ms event delivery on an open connection.

Apache Pulsar

All events flow through Pulsar, the same distributed messaging system used by Yahoo, Splunk, and Verizon for high-throughput workloads. Guaranteed delivery, topic-based routing, horizontal scaling. This is why we can handle millions of concurrent visitors without degradation.

Microservice architecture

The WebSocket layer, identification service, and enrichment pipeline are independent microservices connected through Pulsar. Each scales independently. The connection server handles socket management. The identification micro handles resolution. They never block each other.

Service Provider pattern

When we identify a visitor, we can hit your server before delivering the result to the browser. Your server looks up the visitor in your database, adds custom fields, checks their subscription status, assigns feature flags. The merged data is what the browser receives. No other identification tool puts your server in the loop like this.

Progressive enrichment

Identity resolution is not a single lookup. We resolve in layers. IP to company in the first 100ms. Person-level match by 300ms. Full enrichment shortly after. Each layer streams to your code as it becomes available. The profile gets richer over the session, not all-or-nothing on a single API call.

One script tag

All of this complexity is invisible to the developer. You add one script tag. You listen for one event. The SDK handles the connection, the reconnection, the offline queue (up to 1,500 events), the iframe-based state persistence across page loads, and the three-level room hierarchy that routes events to the right visitor, SDK, and account.

How we think about the product

Infrastructure, not application

We are not building a dashboard for marketers. We are building a runtime for developers. The value is in what you build on top of SQID, not in what we show you in a UI.

Stream, don't store

SQID is a pipe, not a warehouse. Data flows from source to destination in real-time. We do not ask you to store visitor data in our system and query it later. We deliver it to your code the moment it exists.

Your server in the loop

Most identification tools are black boxes. Data goes in, a result comes out, take it or leave it. SQID puts your server in the middle. You control what gets enriched, what gets filtered, what gets delivered to the browser.

One SDK, not four vendors

Identity resolution, behavioral streaming, real-time enrichment, frontend-backend sync. These used to require four separate tools with four separate contracts. SQID handles all of it through a single integration point.

The team

We are a small team that ships fast and talks to customers constantly. SQID is a product of ScriptEngine, Inc.

If you want to talk about what you are building, reach out. We are developers building for developers. The best ideas for this product have come from watching what our customers do with it.

Get started Read the docs