stealth.qleapventures.com

Stealth Analytics ships a 0.7 KB frontend payload, the smallest of the four tools compared on its own site. That number matters if you are trying to protect a Lighthouse performance score or a Core Web Vitals budget: a smaller script downloads, parses, and executes faster, and Stealth Analytics states its script is engineered to load in milliseconds without blocking rendering. The comparison below uses the figures published on Stealth Analytics' own site, so treat the other vendors' numbers as Stealth's characterization rather than independently verified measurements.

Script size comparison

The gap between GA4 and the rest is roughly an order of magnitude. GA4 is also the only tool here that is typically loaded through Google Tag Manager or a gtag.js snippet, which can pull in additional requests beyond the base script. Stealth Analytics, Simple Analytics, and Plausible all position themselves as lightweight alternatives, and their listed sizes cluster within a few kilobytes of each other.

What the 0.7 KB figure does and does not cover

Stealth Analytics describes its frontend script as "microscopic" and says it is "virtually invisible to the browser." The 0.7 KB refers to that frontend script. The product also supports a second ingestion path: you can skip the browser script entirely and send a standard JSON payload via POST to its edge endpoint from any language or framework. In that mode there is no frontend script at all, so the 0.7 KB does not apply to your page weight.

The site's headline is "If it can make a POST request, we can track it," and it lists REST API ingestion, backend system events, and mobile-optimized dashboards as first-class features rather than add-ons.

Why script size is only part of the performance question

A small script is necessary but not sufficient for a clean performance score. Three things determine the real cost:

1. Transfer size vs. parse/execute cost. A 0.7 KB file is trivial to download, but the JavaScript still has to be parsed and run. Stealth Analytics claims millisecond load times and no render blocking; those are the claims to verify with your own Lighthouse or WebPageTest run.
2. Request count. One small script is better than one small script plus a tag manager plus a consent wrapper. If you use Stealth's API path instead of the script, you can remove the request from the critical path entirely.
3. What you actually measure. If you only need pageviews, a 0.7 KB script is plenty. If you need custom events, Stealth Analytics supports them, but the free tier caps you at 2 custom events per project, so the practical ceiling depends on your plan.

Choosing based on this comparison

• If your priority is the smallest possible browser payload, Stealth Analytics at 0.7 KB is the lowest number in this set, and its API-first design lets you avoid a frontend script altogether.
• If you want a mature, widely documented ecosystem and can absorb the weight, GA4 is the heaviest option here by a wide margin.
• If you want a lightweight script with a longer track record in the privacy-first analytics space, Simple Analytics (~3.0 KB) and Plausible (~1.2 KB) sit between the two extremes.

One caveat on pricing: Stealth Analytics lists a free tier (5,000 events, 30-day retention) and paid tiers at $14/mo and $39/mo, and its pricing section mentions "upgrade" but no payment platform details are given on the page. Confirm current terms on the site before committing, and note that the free tier's 2-custom-events limit may matter more to your setup than the 0.7 KB script size.

Stealth Analytics is a privacy-first, developer-oriented analytics platform built around one core idea: if a system can make a POST request, it can send telemetry to Stealth. Instead of limiting tracking to browser pageviews, it accepts raw event payloads from a tiny frontend script or directly from backend services, edge workers, payment funnels, or hardware projects. It is aimed at developers who want speed, minimal footprint, and freedom from per-domain pricing.

What makes it different from traditional analytics

Most analytics platforms are built around the browser. They assume your data comes from a JavaScript snippet watching page loads. Stealth Analytics treats the browser as just one possible source.

The site states its core capability plainly: "If it can make a POST request, we can track it." That means the same platform can ingest:

• Web traffic from a frontend script
• Backend system events from a server
• Custom conversions from a payment funnel
• Telemetry from a background worker or a robotics project

This is a meaningful shift. Traditional tools often require a specific SDK or software kit. Stealth's documented approach is to accept a standard JSON payload sent to an edge endpoint, so any language or framework that can issue an HTTP POST can participate.

How ingestion works

There are two documented channels, and you can use either or both.

Frontend script

A small script is dropped into the HTML <head> for web traffic. The site describes the payload as 0.7 KB and the install as 1 line.

REST API

You bypass the browser entirely and hit the edge workers directly. The documented pattern is a standard JSON payload:

await fetch('https://api.stealth...', {
  method: 'POST',
  body: JSON.stringify({ name: 'sale' })
});

The expected result is that the event lands in your dashboard, whether it originated from a browser, a server cron job, or a custom backend process. The site frames this as "two minutes to first event."

Footprint and performance

Analytics scripts can hurt performance scores if they are heavy or block rendering. Stealth positions its script as "virtually invisible to the browser," loading in milliseconds without blocking rendering.

The site provides a direct size comparison:

If page speed or Core Web Vitals matter to you, the 0.7 KB figure is the headline number. Smaller scripts generally mean less main-thread work and less render-blocking risk, though real-world impact also depends on how and where the script is loaded.

Pricing and usage model

Stealth does not charge per domain. Its usage-based buckets cover your entire portfolio, so tracking one site or fifty counts toward the same event limit. The site lists three tiers:

All tiers include full CSV exports. The "upgrade" signal on the page points to the paid tiers, so the free plan is a real entry point but with a 30-day retention cap and a low custom-event ceiling.

Who it is for

Stealth Analytics fits developers and small teams who:

• Want to track events beyond pageviews, including server-side and backend processes
• Prefer a REST API over a vendor-specific SDK
• Care about a minimal frontend footprint
• Run multiple sites and do not want per-domain billing
• Are comfortable formatting JSON payloads and making HTTP requests

It is less suited to non-technical users who expect a plug-and-play dashboard with no code, or to teams that need the deep out-of-the-box integrations and reporting ecosystem of a larger platform.

Mobile and dashboard

The dashboard is described as fully responsive and engineered to feel like a native app, so you can check active web traffic on a commute or verify a server cron job from your phone. This matters if you monitor systems away from a desk.

What to verify before committing

The site does not publish details on data residency, retention enforcement mechanics, or how privacy compliance is handled beyond the "privacy first" positioning. If those are hard requirements for you, confirm them directly before migrating. The free tier is the lowest-risk way to test whether the ingestion model fits your stack: send one frontend event and one backend event, then confirm both appear in the dashboard.

Stealth Analytics accepts any event that can be sent as a POST request, so you can track from a browser script, a backend worker, a payment funnel, or any other system that speaks HTTP. The frontend path is a one-line script in your HTML head; the backend path is a standard JSON payload fired at the edge endpoint from any language or framework. No SDK is required, and the site claims you can reach a first event in about two minutes.

Frontend: one line in the head

For web traffic, drop the provided script into the <head> of your HTML. The site describes the payload as 0.7 KB, compared with roughly 45.0 KB for Google Analytics 4, 3.0 KB for Simple Analytics, and 1.2 KB for Plausible, and says it loads in milliseconds without blocking rendering.

Steps:

1. Copy the script tag from the Stealth Analytics dashboard or guides.
2. Paste it into your HTML <head>.
3. Load the page and confirm the event appears in the dashboard.

Expected result: page traffic shows up in your dashboard without additional configuration.

Backend: POST a JSON payload

To track server-side processes, custom conversions, or anything outside the browser, send a standard JSON payload directly to the edge endpoint. The site's example uses fetch:

await fetch('https://api.stealth...', {
  method: 'POST',
  body: JSON.stringify({ name: 'sale' })
});

The same pattern works from any language or framework that can make an HTTP POST request — the site's framing is "If it can make a POST request, we can track it."

Steps:

1. Build a JSON body with at least an event name, e.g. { "name": "sale" }.
2. POST it to the edge endpoint from your server, worker, or script.
3. Verify the event lands in the dashboard alongside your web traffic.

Expected result: backend events such as database processes and custom conversions appear in the same dashboard as pageviews.

What you can track

Plan limits that affect event volume

Custom events per project and event volume are capped by plan, so check your tier before wiring up many event types.

All tiers include full CSV exports, and pricing is per usage bucket rather than per domain — one site or fifty count toward the same limit.

Common snags

• Custom event cap. The Free plan allows 2 custom events per project. If your backend sends more distinct event names than your plan supports, some will not be tracked.
• Retention window. Free retention is 30 days; older events are not available for export on that tier.
• Endpoint details. The example endpoint is truncated in the source. Use the exact URL from your dashboard or guides rather than the abbreviated form shown here.

Yes. Stealth Analytics accepts telemetry from anything that can make a POST request, not just browsers. You can send events from a website, a background worker, a payment funnel, a server process, or a hardware project, either through the small frontend script or by hitting the edge endpoint directly with a JSON payload. The only requirement stated on the site is that the source can issue a POST request.

What "non-browser" tracking actually means here

Most analytics platforms assume a browser is the source of every event. Stealth Analytics separates ingestion from the browser entirely. Its stated position is: "If it can make a POST request, we can track it."

That opens up three categories the site explicitly calls out:

• Backend system events — send strict event payloads from your server to track database processes and custom conversions.
• Payment funnel events — fire events at points in a checkout or conversion flow that never render a page.
• Non-web projects — the site names "that robotics project in your garage" as a valid source.

How to send an event without a browser

The site describes two ingestion paths.

1. Frontend script (for web traffic)

Drop the script in your HTML <head>. This is the standard path for pageviews and browser-side activity.

2. REST API / edge workers (for everything else)

Bypass the browser completely and hit the edge endpoint directly. No SDK or software kit is required — format a standard JSON payload and send it from any language or framework.

The example the site provides:

await fetch('https://api.stealth...', {
  method: 'POST',
  body: JSON.stringify({ name: 'sale' })
});

The site frames the whole setup as "two minutes to first event": script in the head for web traffic, API for everything else.

Checking non-browser events from a phone

The dashboard is described as engineered to feel like a native app and fully responsive. The stated use cases are checking active web traffic on a commute or verifying a server cron job from the gym — so mobile viewing is treated as a first-class scenario, not an afterthought.

What this means for your setup

Custom events are capped per plan: 2 per project on Free, 10 on Indie Hackers, 50 on Pro. If your backend tracking depends on many distinct event names, that per-project limit is the constraint to check before choosing a tier.

Where to look next

If you are deciding between plans based on event volume and site count, the usage buckets cover your whole portfolio rather than charging per domain — one site or fifty count toward the same limit. If you want to compare the script's footprint against other tools, the site lists GA4 at ~45.0 KB, Simple Analytics at ~3.0 KB, Plausible at ~1.2 KB, and Stealth Analytics at 0.7 KB.

Stealth Analytics charges by total event volume across your whole portfolio, not by domain — so the number of sites you run never changes your bill. Pick a plan by matching your combined monthly events and your retention and custom-event needs: Free ($0, 5,000 events, 30-day retention, 2 custom events per project) for hobby projects, Indie Hackers ($14/mo, 50,000 events, unlimited retention, 10 custom events) for projects with real traction, and Pro ($39/mo, 250,000 events, unlimited retention, 50 custom events) for scaling SaaS and ecommerce.

The three plans side by side

The only things that scale with price are event volume, retention, and the custom-event ceiling per project. Everything else — unlimited sites, full CSV exports — is identical across tiers.

Why site count doesn't decide your plan

The pricing page states it directly: "We do not charge you per domain. Our usage based buckets cover your entire portfolio. Track one site or fifty, it all counts toward the same limit."

That means a single 5,000-event bucket covers every property you own. If you run five small sites that each generate 900 events a month, you're at 4,500 total and still on Free. If one site alone pushes 6,000 events, you've outgrown Free regardless of how many other domains you have.

The practical consequence: consolidate your thinking. Add up events across all sites, workers, and backend systems before choosing a tier.

What counts as an event

Stealth Analytics is built around raw event ingestion, not just pageviews. The homepage describes sending telemetry "from your website, your background worker, your payment funnel, or that robotics project in your garage," and notes you can "bypass the browser completely and hit our edge workers directly" via a standard JSON POST request.

So your event count isn't just traffic. It includes:

• Frontend pageviews from the 0.7 KB script
• Backend system events from your server
• Custom conversions and funnel steps
• Any other POST payload you send to the edge endpoint

If you're tracking server-side database processes or payment funnel steps alongside web traffic, those all draw from the same bucket. A site with modest traffic but heavy backend instrumentation can burn through events faster than raw pageview counts suggest.

Matching your situation to a plan

Free — hobbyists and side projects. The page labels it "Perfect for hobbyists." Choose it if your combined monthly events stay under 5,000, you only need 30 days of history, and two custom events per project covers your tracking. The 30-day retention is the real constraint here: if you want to compare this month to six months ago, Free won't have the data.

Indie Hackers — projects with traction. At $14/mo you get 10x the events (50,000), unlimited retention, and 10 custom events per project. The jump to unlimited retention is the meaningful upgrade — it's what lets you keep historical baselines. Pick this if you've outgrown 5,000 events, need long-term data, or your custom-event definitions have grown past two per project.

Pro — scaling SaaS and ecommerce. $39/mo covers 250,000 events, unlimited retention, and 50 custom events per project. This is for portfolios where event volume is genuinely large — high-traffic sites, or products instrumenting many distinct conversion and backend events.

How to estimate before you commit

1. Count events per site. For web traffic, estimate monthly pageviews. For backend events, count how often each tracked process fires per month.
2. Add them all up. Remember every site, worker, and funnel counts toward one shared limit.
3. Check your custom-event needs. Count how many distinct named events you want per project — the Free tier caps this at 2, Indie Hackers at 10, Pro at 50.
4. Decide on retention. If you need history beyond 30 days, Free is out.
5. Start on Free and upgrade when you cross a threshold. The page shows an "Upgrade" path, so you can begin at $0 and move up as volume grows.

Common sticking points

• Assuming per-site pricing. The most common miscalculation is budgeting per domain. It's one pooled bucket — fifty sites cost the same as one at equal total volume.
• Forgetting backend events. Server-side and funnel events share the same limit as pageviews. Teams that only count browser traffic often underestimate.
• Overlooking the custom-event cap. Event volume and custom-event count are separate limits. You can be well under your event ceiling and still hit the per-project custom-event cap.
• Treating 30-day retention as enough. If your reporting needs year-over-year or even quarter-over-quarter comparisons, the Free tier's 30-day window will force an upgrade regardless of volume.

If you're unsure, start on Free, watch your actual event consumption for a month, and let the real number — not a guess — tell you whether Indie Hackers or Pro is the right fit.