Creem Affiliate Tracking: How Referrals Get Credited (Native Hub and Beyond)

Creem affiliate tracking is a genuinely interesting case, because Creem is the rare merchant-of-record platform that ships its own affiliate hub and plays nicely with outside tracking tools. That means “how does tracking work on Creem?” has two correct answers: the native hub’s cookie-and-token system, and the metadata-and-webhooks system that tools like Rekomi run. This article explains both, with the real field names, so you can pick the right rail for your program instead of the first one you bump into.

Let me name my seat before we start: I run Rekomi day to day, and we have our own page in Creem’s official docs. I’m going to be genuinely fair to Creem’s native hub anyway, because for a single-rate program it’s free and it’s good, and pretending otherwise would just cost me your trust.

The lay of the land:

Native hub: Creem sets a tracking cookie on the affiliate’s link click, uses a signed creem_ref token for embedded checkouts, and pays one program-wide commission rate.

Third-party rail: your site stores the referral, stamps it into checkout metadata as rekomi_ref, and Creem’s webhooks hand it back on every payment, renewal included.

They coexist: creem_ref is reserved for Creem’s feature, rekomi_ref is a plain metadata key, and the two never collide.

Creem affiliate tracking, two ways

Which one should you care about? Quick test: if you want one commission rate for every affiliate and you’re happy with invite-only recruiting, the native hub is honestly a no-brainer at zero cost. If you want per-affiliate rates, coupon-code attribution, an application page, or payouts your affiliates don’t need crypto or a separate KYC flow for, you’ll be on a third-party tool. Most brands I talk to start with the first and graduate to the second, which is exactly the path the Creem software comparison maps out.

How Creem’s native hub tracks a referral

Creem’s own system, documented in their affiliate program docs, works like this: you invite an affiliate by email, they accept at affiliates.creem.io, and they get a referral link. When a visitor clicks it, Creem sets a tracking cookie in that browser, and purchases inside the cookie window attribute to the affiliate. For embedded checkouts, where a cookie can’t cross the iframe boundary, Creem uses a signed URL token called creem_ref that your embed forwards automatically. It’s a tidy design and I’ll happily say so.

The trade-offs are structural, not bugs, and Creem documents them openly:

• One rate for everyone. The program has a single commission percentage; per-affiliate rates and per-affiliate product restrictions aren’t supported.
• Invite-only. There’s no public application flow; you recruit by email, one invite at a time.
• Payouts require KYC. Affiliates verify identity through Sumsub, then get paid on the 1st and 15th by bank transfer ($7 or 1% fee) or USDC (2% fee via Mural), with a $50 minimum balance.

For a small program with a handful of trusted partners, honestly, that’s plenty. The rest of this article is about what happens when it isn’t.

The third-party rail: rekomi_ref through checkout metadata

Here’s how it plays out on the metadata rail. A visitor lands on your site through an affiliate link (?via=kai or any of 19 recognized params), and a script stores the referral in their browser for 90 days. At checkout time the referral gets stamped into Creem’s metadata, by one of two routes:

API checkout sessions: include it in the create call:

metadata: { rekomi_ref: window.Rekomi?.getReferral?.() }

No-code payment links: decorate the link with Creem’s bracket syntax, and Creem copies the value onto the checkout:

?metadata[rekomi_ref]=kai

Why rekomi_ref and not creem_ref? Because creem_ref is reserved: it’s the signed token Creem’s own hub uses, and a third-party tool squatting on it would break the native feature. Keeping the keys separate is what lets both systems run on one store without stepping on each other, and it’s a small detail I really respect Creem for getting right.

The metadata’s best property comes next: Creem copies checkout metadata onto the subscription, and the subscription re-sends it on every renewal webhook. Stamp once, attribute forever!

The webhook side: why “select all events” matters

Creem’s webhook form has an event picker, and the single most common Creem tracking mistake is checking only the events that sound relevant. Pick a subset and tracking doesn’t error – it just quietly misses sales. Select all events; the tool ignores what it doesn’t need.

What the events actually do is a nice illustration of Creem’s checkout model, which splits money across two event types:

• checkout.completed carries the money for one-time purchases (order type onetime).
• subscription.paid carries the money for subscriptions: the first charge and every renewal, each with its own transaction ID for dedup.
• subscription.trialing records a $0 trial start – the affiliate sees their referral landed, but commission waits for the first real charge.
• refund.created claws commission back when a refund succeeds, proportionally on the pre-tax share of partial refunds.
• dispute.created claws back the dispute’s pre-tax share, same math as the refund path. Creem sends a real dispute signal, which not every platform in this space does.

The two-event money split is the trap to know: a checkout that starts a subscription also emits a checkout.completed, so a tool that credits both events double-pays the first month. The split by order type (checkout events for onetime, subscription.paid for recurring) is what keeps each dollar commissioned exactly once.

Coupon codes: attribution with no click at all

This is the Creem rail’s quiet superpower, and my favorite mechanism on the whole platform. Creem’s webhooks include the discount code the customer redeemed, so a code can literally act as the referral itself. When a code is registered to an affiliate in Rekomi (say KAI15 for Kai), a customer checking out with it credits Kai – no link click, no cookie, no metadata required.

One honest caveat while it’s fresh: the attribution engine for this is live today, but self-serve code registration for Creem programs hasn’t landed in the dashboard yet. If you want coupon affiliates on your Creem program now, message us and we’ll set your codes up with you while the UI catches up.

That matters because codes travel where links can’t: podcast reads, YouTube descriptions people retype, conference slides, TikToks. A customer who hears “use KAI15” on a podcast Monday and types your URL directly on Friday is invisible to click tracking, and there she is in your conversion list anyway, correctly attributed! The code even outranks link signals when both are present, on the logic that typing a code at checkout is the customer’s most explicit statement of who sent them.

The full credit ladder on the Creem rail

When a money event arrives, the affiliate is resolved in strict priority order. So, who wins when signals conflict? The ladder answers it mechanically:

1. The redeemed discount code, matched against a registered affiliate coupon (explicit intent at checkout beats everything).
2. metadata.rekomi_ref on the checkout or subscription (the link click’s stamp).
3. request_id, Creem’s per-checkout tracking field, read opportunistically: if it happens to match an affiliate’s slug it credits, and a brand’s own order ID in that field just falls through.
4. Customer history: a prior attributed purchase by the same Creem customer credits the same affiliate (the safety net for renewals and repeat buys).
5. No one: the sale records unattributed, reviewable by hand.

Run the math on what the ladder protects. A $20/mo product at 30% recurring pays an affiliate $6 per customer per month; over a 14-month average lifetime that’s $84 per referred customer. Every rung exists so one of those months doesn’t silently fall off the ledger, and honestly, watching the ladder catch a codeless, cookieless podcast sale is the kind of thing that makes this job fun.

Can the native hub and a third-party tool run together?

Yes, and cleanly. The reserved creem_ref token and the rekomi_ref metadata key never touch, so a brand can keep existing hub affiliates where they are while newer partners onboard on the other rail (that’s the usual migration shape, and there’s no forced cutover day). The one rule: give each affiliate one home, because a partner with links on both rails would attribute in whichever system saw the click, and reconciling that is nobody’s idea of a good Tuesday.

On payouts, the two rails differ more than the tracking does: the hub pays bank or USDC with Sumsub KYC and a $50 minimum, while Rekomi’s payout rail covers 165+ countries (Stripe Express in 42, bank deposits in 60 more, PayPal in 66 more) with tax forms handled. Full setup for the Rekomi side lives in the Creem affiliate program guide.

FAQ: tracking referrals on Creem

Does Creem have built-in affiliate tracking?

Yes. Creem’s native affiliate hub tracks clicks with a cookie (plus a signed creem_ref token for embedded checkouts) and pays a single program-wide commission rate, free of charge.

Can affiliates earn from discount codes on Creem?

Yes, on the Rekomi rail. Creem’s webhooks carry the redeemed discount code, so a code registered to an affiliate attributes the sale even when there was never a click.

Do renewals keep crediting the affiliate?

Yes. Checkout metadata is copied to the subscription and re-sent on every subscription.paid renewal event, and customer history backs it up if metadata is ever missing.

What happens on refunds and chargebacks?

Commissions reverse automatically: refunds claw back proportionally on the pre-tax amount when they succeed, and disputes claw back their pre-tax share the moment Creem reports them.

Why can’t my tool use creem_ref?

Because Creem reserves creem_ref for its own affiliate feature’s signed token. Third-party tools use their own metadata keys (Rekomi uses rekomi_ref) so both systems can coexist.

Pick your rail and run a test sale

You now know more about Creem attribution than most tools’ sales pages will tell you, so use it: if the native hub fits, set your rate and send your first invite today. If you need per-affiliate rates or code-based attribution, connect the Creem integration, run one test-mode checkout with a code and one with a link, and check that both land on the right affiliate. Two test sales and you’ll trust the system with real ones.