Sub-ID Tracking: Placement-Level Attribution for Affiliate Campaigns

Most affiliate reporting stops at the partner. You can see that a publisher sent four thousand clicks and closed sixty conversions last month, and you can see the commission you owe them. What you usually can't see is the thing that actually matters for growth: which slice of that publisher's traffic did the work. A single publisher might run a newsletter, three review pages, a coupon widget, and a paid-search arm — and inside that one blended number, a single placement could be carrying the whole program while the rest quietly bill you for clicks that never convert.

That blind spot is what sub-IDs exist to close. A sub-ID lets a publisher stamp every click with a label describing where it came from, and lets you read that label back on the conversion it eventually produced. Done right, it turns "this partner works" into "this specific placement, on this specific page, is where the revenue is" — which is the difference between renewing a flat deal and actually optimizing one.

What a sub-ID actually is

A sub-ID is an optional parameter a publisher appends to their tracking link — ...?sub_id=... — to identify the source of a click before it ever reaches you. The important detail is who owns the value: the publisher does. TrackingMD doesn't dictate what goes inside it. It's a free-form tag the partner sets to encode whatever dimension they care about, and it rides along on the link as an ordinary query parameter.

That ownership is the whole point. Your program-level data is organized around your structure — programs, links, commission terms. The sub-ID is the one field that carries the publisher's structure into that data. It's their taxonomy of their own traffic, expressed in a string they control, arriving pre-attached to every click. You don't have to guess how a partner thinks about their inventory; they tell you, one click at a time.

Because it's publisher-supplied and free-form, two partners will almost never use it the same way. One might drop a raw placement ID into it; another might encode a campaign name; a third might build a compound string that packs several dimensions together. That's fine. The parameter is a channel, not a schema — its job is to preserve whatever the publisher put there, faithfully, through to the conversion.

How publishers use sub-IDs to segment traffic

From the publisher's side, a sub-ID is a lightweight analytics primitive that costs nothing to adopt. They already run one tracking link for your program; adding ?sub_id= lets them fork that single link into as many logically distinct sources as they want, without you having to issue a new link for each one.

Common ways a publisher segments with it:

• By placement — the exact ad slot, sidebar unit, or in-content link that produced the click, so they can tell a hero banner from a footer link.
• By content page — which review, guide, or comparison article the click came off of, so their best-converting pages get more of the offer.
• By campaign — a seasonal push, an email blast, or a paid-traffic buy kept separate from organic placements.
• By creative — which headline, image, or call-to-action variant a visitor clicked, feeding their own A/B tests.
• By audience or channel — newsletter versus social versus on-site, so the partner knows which of their own channels to invest in.

Here's the mental model, expressed as a rough example of what a single publisher's sub-ID values might encode:

None of that structure is imposed by you. You simply receive it — which is exactly why it's so useful.

The plumbing: passthrough and persistence

The reason sub-IDs are worth writing about at all is that the naive version of this quietly loses the data. A tracking click isn't a single request; it's a redirect. The visitor hits your tracking link, gets bounced through attribution, and lands on the destination page. If the parameter only lives on the first hop, it's gone by the time anything converts — and a conversion that can't be tied back to its sub-ID is just noise.

TrackingMD handles this with deep-link passthrough: the sub_id supplied on the tracking link is forwarded through the redirect to the destination, and — critically — it's stored on the underlying records at each stage. The value is captured on the click, carried onto the impression, and written onto the resulting conversion. That persistence across the whole chain is what makes placement-level attribution real rather than aspirational.

The payoff is a clean join. Because the same sub-ID is present from the first click all the way to the sale, revenue you book weeks later can be traced back to the exact source the publisher tagged at the top of the funnel. You're not inferring which placement drove a conversion from timestamps and guesswork — the placement label is sitting on the conversion record itself.

Reading the data: which placements actually convert

Once the sub-ID is riding on your clicks and conversions, the advertiser-side question changes shape. Instead of asking "is this publisher worth it?", you can ask "which parts of this publisher are worth it?" — and the answer is in your own data.

That reframing is where the money is:

• Concentration becomes visible. It's common for a small handful of placements to produce most of a partner's conversions. When you can see it, you can lean into it — better terms, better creative, more inventory on the sources that earn.
• Dead weight becomes visible too. Placements that generate clicks but never convert stop hiding inside a healthy-looking blended total. That's a conversation to have with the partner, not a cost to keep absorbing.
• Optimization gets a shared language. When you and a publisher are both looking at the same sub-ID breakdown, "send us more of review-page-a" is a concrete, actionable request instead of a vague nudge to "send better traffic."

And because sub_id is included in TrackingMD's data exports, none of this is trapped behind a single view. You can pull the raw records — sub_id attached — into your own warehouse or spreadsheet, cut conversion and revenue by sub-source, and fold it into whatever partner scorecards or margin analysis you already run. The label a publisher set on a link becomes a dimension you can slice on for good.

When sub-IDs get gamed: detecting manipulation

Any field a publisher controls is a field a bad actor can abuse, and sub-IDs are no exception. Because the value is publisher-supplied and free-form, it's a natural target for manipulation — churning through fabricated sub-source values to disguise low-quality or fraudulent traffic, spraying invented placements to make junk look diversified, or shaping the parameter to game whatever attribution or payout logic sits downstream. Left unchecked, the same field that gives you placement-level clarity can be used to launder placement-level fraud.

TrackingMD's Guardian fraud engine watches for exactly this. It includes a SubIdManipulationRule that flags abusive or manipulated sub_id patterns, so suspicious behavior surfaces as part of the same fraud-prevention layer that guards the rest of your traffic — rather than living in a blind spot precisely because the data looks granular. The intuition is straightforward: honest segmentation produces sub-IDs that behave like a publisher's real inventory, and manufactured patterns don't. Guardian is built to tell the difference, which means you can trust your placement-level numbers instead of having to wonder whether the granularity itself is being played against you.

The shift worth making

The habit worth breaking is treating a publisher as a single line item. A partner is not one traffic source; it's a portfolio of placements, pages, campaigns, and channels, each with its own economics — and the aggregate number on your partner report averages all of them into a figure that's true but rarely useful.

Sub-IDs are the cheapest way to stop averaging. The publisher adds a parameter they were happy to add anyway; TrackingMD carries it through the redirect and pins it to the click, the impression, and the conversion; Guardian keeps it honest; and your exports hand you the whole thing to slice however you like. The result is attribution that finally matches how traffic actually works — not "which partners," but "which placements" — and once you can see your program at that resolution, going back to blended partner totals feels like flying blind.