---
title: "Signup Source Tracking: Why It Matters and How to Do It | Statusentry"
description: "Know which channels bring real signups, not just clicks. Why signup source tracking matters for SaaS, and how to set it up with UTMs, referrers, click IDs and first-touch cookies."
url: https://statusentry.com/blog/signup-source-tracking
updated: 2026-10-26
---

[All posts](https://statusentry.com/blog) Guides

# Signup Source Tracking: Know Where Your Customers Really Come From

Analytics tells you where visitors come from. It rarely tells you where customers come from. Why signup source tracking matters for a SaaS business, and a practical way to set it up with UTM tags, referrers, ad click IDs and a first-touch cookie.

Oct 26, 2026 8 min read by Statusentry team

Most SaaS teams can tell you how many people visited their site last month and which channel sent them. Far fewer can answer a simpler question: *where did our paying customers come from?* Those are different questions, and the gap between them is where marketing budgets quietly disappear.

Signup source tracking closes that gap. The idea is simple: when someone creates an account, you save where they originally came from on the account itself. Once that's in place, every later event, such as activation, upgrade or churn, can be traced back to a channel. This post covers why that matters and how to set it up without a large analytics stack.

## Traffic is not the same as signups

A channel can look great in your analytics dashboard and still bring almost no customers. A few common patterns:

- **A blog post ranks well and brings thousands of visitors**, but they're students researching a topic, not teams looking for a tool.
- **An ad campaign has a great click-through rate**, but the clicks come from people who bounce at the pricing page.
- **A small community mention brings fifty visitors**, and ten of them sign up and stay for years.

If you only measure traffic, you'll invest in the first two and ignore the third. Signup source tracking lets you rank channels by what they actually produce: accounts, activated users and revenue.

## Why it matters

### Spend money where it works

Paid channels are where this pays off fastest. Ad platforms report their own conversions, but each one tends to credit itself, and their numbers rarely add up to your real signup count. When the source is stored on the account in your own database, you have one neutral record to compare every channel against. You can calculate cost per signup and cost per paying customer per channel, and turn off the campaigns that bring clicks but no customers.

### See quality, not just quantity

Signups are not all equal. With the source on every account, you can ask better questions:

- Which channel's signups actually complete setup?
- Which channel's trials turn into paid plans?
- Which channel's customers are still with you after a year?

A channel that brings half the signups but twice the paying customers is the better channel. You can only see that if the source travels with the account.

### Understand why people leave

When signups leave early, the source often explains part of it. People who arrive from an ad promising one thing and find another will churn faster than people who searched for exactly what you offer. If one channel's users drop off at a particular step, that's a messaging problem you can fix on the landing page, not a product problem.

### Know what your content is worth

Content marketing is hard to justify without data. If you store the landing page along with the source, you can see which blog posts and guides lead to signups, not just page views. That tells you what to write more of.

## What to capture

A useful signup source record is small. These fields cover almost every case:

| Field | Where it comes from | Example |
| --- | --- | --- |
| Source | utm_source | google, reddit, newsletter |
| Medium | utm_medium | cpc, email, social |
| Campaign | utm_campaign | spring-launch |
| Content / term | utm_content, utm_term | ad variant, keyword |
| Referrer | document.referrer (hostname) | www.google.com, news.ycombinator.com |
| Click ID type | Ad platform URL parameter | gclid, msclkid, rdt_cid |
| Landing page | First page they saw | /blog/incident-templates |
| Date | When you first saw them | 2026-10-26 |

A few notes on each:

- **UTM parameters** are the most reliable signal, because you control them. Tag every link you share in ads, emails, newsletters and social posts, and agree on a naming convention (lowercase, consistent spellings) before the data gets messy.
- **The referrer** catches what you didn't tag: search engines, communities, other blogs, and increasingly AI assistants. Modern browsers usually send only the referring site's domain, not the full URL, so you'll see `google.com` but not the search query. For search terms, use Google Search Console.
- **Ad click IDs** are added automatically by ad platforms: `gclid`, `gbraid` and `wbraid` for Google Ads, `msclkid` for Microsoft Ads, `fbclid` for Meta, `rdt_cid` for Reddit, `li_fat_id` for LinkedIn and `twclid` for X. Their presence tells you the visit came from a paid ad, even if someone forgot the UTM tags.
- **The landing page** shows which content started the journey.

## First touch or last touch?

People rarely sign up on their first visit. They read a blog post, leave, come back a week later by typing your URL, and sign up then. So which visit gets the credit?

- **First touch** credits the channel that introduced them to you.
- **Last touch** credits the channel of the visit where they signed up.

For a small SaaS team deciding where to invest, first touch is usually the more useful default. It answers "how do people discover us?", which is the question behind most marketing decisions. Last touch tends to over-credit "direct" visits and branded searches, which mostly reflect people who already know you.

One refinement makes first touch much more accurate: **don't let a "direct" visit lock in the source.** If someone's first recorded visit had no source at all (a typed URL, a bookmark, a link from a chat app), and a later visit comes from a real channel, replace the direct record with the real one. A known source wins over an unknown one; an earlier known source wins over a later one.

## How to set it up

You don't need a customer data platform for this. A short script on your marketing site and one extra field at signup is enough. Here's the approach we use.

### 1. Capture the source on the first visit

On every page of your marketing site, read the UTM parameters, the referrer and any click ID from the current URL. If you don't already have a stored source, or the stored one is "direct" and this visit has a real source, save it.

### 2. Store it where your app can read it

This is where many setups break. Your marketing site and your app often live on different hosts, such as `example.com` and `app.example.com`, and signup usually involves redirects to a login provider. Browser storage like `localStorage` is tied to a single origin, so the app can't see what the marketing site saved.

A **first-party cookie on the parent domain** (`domain=.example.com`) solves this. Both the site and the app can read it, and it survives the trip through a Google sign-in or another identity provider. Give it a sensible lifetime, such as 90 days, so a visitor who comes back weeks later is still attributed.

A simplified version of the capture script:

signup-source.js (simplified)

```
(function () {
  var q = new URLSearchParams(location.search), data = {};
  var put = function (k, v) { if (v) data[k] = String(v).slice(0, 100); };

  put("src", q.get("utm_source"));
  put("med", q.get("utm_medium"));
  put("cmp", q.get("utm_campaign"));

  // Referrer: ignore your own domains and login providers
  try {
    var host = new URL(document.referrer).hostname;
    var own = /(^|\.)example\.com$/.test(host);
    var login = /(^|\.)accounts\.google\.com$/.test(host);
    if (!own && !login) put("ref", host);
  } catch (e) {}

  ["gclid", "gbraid", "wbraid", "msclkid", "rdt_cid", "fbclid", "li_fat_id", "twclid"]
    .some(function (id) { if (q.get(id)) { put("cid", id); return true; } });

  var known = function (d) { return d && (d.src || d.ref || d.cid); };
  var m = document.cookie.match(/(?:^|;\s*)signup_src=([^;]*)/);
  var old = null;
  try { old = m ? JSON.parse(decodeURIComponent(m[1])) : null; } catch (e) {}
  if (old && (known(old) || !known(data))) return;   // first real source wins

  put("lp", location.pathname);
  put("ts", new Date().toISOString().slice(0, 10));
  document.cookie = "signup_src=" + encodeURIComponent(JSON.stringify(data)) +
    "; domain=.example.com; path=/; max-age=7776000; SameSite=Lax; Secure";
})();
```

### 3. Save it on the account at signup

When the account is created, the app reads the cookie and saves its contents on the user or organization record. That's the step that turns attribution from a marketing report into data you can join with everything else: plan, activation, revenue, churn.

Save it once and never overwrite it. The point is to remember how this customer first found you.

### 4. Don't lose ad click IDs to slow scripts

If your analytics or ad tags load late (for example, deferred to improve page speed), a visitor who clicks "Sign up" in the first second can leave before the tag has recorded the click ID. The ad platform then can't match the conversion to the click. A small fix: when a click ID is in the URL, copy it onto your signup and login links so it reaches the app either way.

### 5. Ask, too

Tracking misses a lot of real word of mouth: a recommendation in a team chat, a podcast mention, a colleague saying "we use this", or an AI assistant suggesting your product without a clickable link. All of those show up as "direct."

Add one optional question to signup or onboarding: **"How did you hear about us?"** Keep it short, offer a few choices plus a free-text "Other," and don't make it required. Self-reported answers are messy, but they often reveal channels that no tracking script can see. Use both: tracked data for the numbers, answers for the story behind "direct."

## Common mistakes

- **Untagged links.** Every link you share without UTM tags becomes a referrer at best and "direct" at worst. Build tagging into your checklist for ads, emails and social posts.
- **Inconsistent naming.** `Reddit`, `reddit` and `reddit.com` are three sources in a report. Pick one convention and write it down.
- **Counting your own domains as sources.** If your app or login provider shows up as a referrer, filter it out, or every returning user will look like they came from your own site.
- **Overwriting the source later.** If the source is updated on each login, you lose the information you collected it for.
- **Storing it only in analytics.** Analytics tools sample, expire and stay separate from your billing data. The source belongs on the account in your own database.
- **Ignoring privacy rules.** Attribution data is about real people. Collect only what you need, keep it in first-party storage, mention it in your privacy policy, and check whether your audience's regulations (such as GDPR in the EU) require consent for advertising cookies and click IDs. This isn't legal advice, so if you're unsure, ask someone who specializes in it.

## Putting it to work

Once a few weeks of signups have a source attached, the useful reports are simple. Group accounts by source and compare signups, activation rate, conversion to paid and retention. Then add what you spent on each channel. You'll quickly see which channels to grow, which to fix, and which to stop paying for.

It's also worth looking at the landing page field on its own. The pages that start the most successful customer journeys are the ones to improve first, link to more often, and write more like.

Signup source tracking isn't glamorous, and it takes an afternoon to set up. But it changes marketing from guessing to measuring, and for a small team, that's the difference between spending money and investing it.

If you're building a SaaS product and want a place to keep customers informed when things go wrong, [create a free Statusentry account](https://app.statusentry.com/signup) or explore our [demo status page](https://demo.statusentry.com/). For more on choosing tools that hold up after launch, read [**How to Choose a SaaS Product**](https://statusentry.com/blog/how-to-choose-a-saas-product).

## Keep reading

[All posts](https://statusentry.com/blog)

Guides 8 min read

### [How to Choose a SaaS Product: Criteria That Matter After the Demo](https://statusentry.com/blog/how-to-choose-a-saas-product)

Every SaaS vendor looks good in the demo. The differences show up during outages, growth spurts and urgent support tickets. The criteria that predict those moments — reliability, scalability, support response time and more — and how to check each before you sign.

Engineering 8 min read

### [Vibe-Coded vs. Professionally Engineered Software: What Changes After Launch](https://statusentry.com/blog/vibe-coded-vs-professionally-engineered-software)

On launch day, a vibe-coded app and a team-built product can look identical. The differences show up later — in security, maintenance and what happens when things break. A fair comparison, and how to tell which one you're buying.

Try Statusentry

## Communicate incidents calmly, transparently, instantly.

Start with a 30-day Enterprise trial. Afterwards, keep the free plan with no time limit.

[Start free](https://app.statusentry.com/signup) [View demo status page](https://demo.statusentry.com/)