Tired of guessing which affiliate links actually make you money? I’ll show you three battle-tested methods, from a quick URL parameter fix to a robust database-driven solution, to finally track your affiliate revenue with precision.

So, You Can’t Track Which Affiliate Links Are Making Money. Let’s Fix That.

I remember a launch we did back in 2019. The marketing team was ecstatic. The affiliate dashboards were lighting up, showing thousands in commissions. The CEO was happy. Then came the dreaded question during a sprint review: “This is great, but which blog post drove the most sales? Should we double down on that content?” Crickets. We had the ‘what’ (total revenue) but absolutely zero ‘why’ or ‘where’. We were flying blind, celebrating a victory we couldn’t replicate because we hadn’t bothered to track our shots. It was a painful, embarrassing lesson in the importance of connecting the click to the conversion.

The Root of the Problem: The Great Disconnect

Let’s be clear about why this is so difficult. When a user clicks your affiliate link, they leave your ecosystem. They land on Amazon, or Commission Junction, or some other network. That network handles the cookie, tracks the purchase, and credits your account. The problem is that the final conversion event lives on their servers, completely disconnected from the initial click event that happened on your server. You’re left with two separate piles of data: a list of outbound clicks from your site, and a pile of money in an affiliate portal, with no easy way to link them.

Unless you build the bridge yourself, you’ll never know if it was the banner ad in the header or the subtle text link in paragraph three that actually made you money.

Solution 1: The Quick & Dirty Fix (URL Sub-IDs)

This is the “I need an answer by tomorrow” solution. It’s manual, a bit hacky, but it works surprisingly well for smaller sites or for quick A/B tests. Most affiliate networks allow you to pass a custom tracking ID, often called a “Sub-ID,” “TID,” or “Click ID.”

You manually append a unique, human-readable identifier to each link you place. For example, if you’re linking to a product in a blog post with the slug ‘best-devops-tools-2024’, you might structure your links like this:

• Link in the introduction: https://affiliate.com/offer?id=your-id&subId=best-devops-tools-intro
• Link in the product review section: https://affiliate.com/offer?id=your-id&subId=best-devops-tools-review1
• Link in the footer call-to-action: https://affiliate.com/offer?id=your-id&subId=best-devops-tools-cta

When you log into your affiliate network’s reporting dashboard, you’ll see a column with these Sub-IDs next to each conversion. It’s not automated, and it can get messy fast, but you’ve instantly gone from zero visibility to knowing exactly which link on which page is a top performer.

Warning: This approach lives and dies by your own consistency. If you forget to add the Sub-ID or make a typo, that click is untracked. It doesn’t scale well past a few dozen links.

Solution 2: The “Proper” Engineering Fix (A Redirect & Tracking Service)

Alright, time to put on our architect hats. This is the robust, scalable, permanent solution. We’re going to build a small internal service to handle click tracking and redirection. The concept is simple: we intercept the click, log it, and then send the user on their way.

Here’s the flow:

1. A user clicks a link on your site that looks like this: https://your-site.com/go/product-a.
2. This hits your server (e.g., an Nginx location block or a route in your web app).
3. Your application generates a unique `click_id` (a UUID is perfect for this).
4. You log this `click_id` to a database table along with useful metadata.
5. You append your unique `click_id` to the real affiliate URL as the `subId`.
6. You issue a 302 redirect to the complete affiliate URL.

Your database table, let’s call it affiliate_clicks, might look something like this on prod-db-01:

Here’s a barebones example of what a simple redirect handler might look like in a Python/Flask app:

import uuid
from flask import Flask, redirect
from your_database_module import save_click # Your DB logic

app = Flask(__name__)

# This could be loaded from a config or another DB table
AFFILIATE_LINKS = {
    "product-a": "https://affiliate.com/offer?id=your-id"
}

@app.route('/go/<link_key>')
def track_and_redirect(link_key):
    if link_key in AFFILIATE_LINKS:
        click_id = str(uuid.uuid4())
        destination_url = AFFILIATE_LINKS[link_key]
        
        # Append our unique ID for tracking
        final_url = f"{destination_url}&subId={click_id}"
        
        # Log to our database
        save_click(
            click_id=click_id,
            source_page=request.referrer, # Not always reliable, but a good start
            destination_url=final_url
        )
        
        # Send the user on their way
        return redirect(final_url, code=302)
    
    # Handle case where the link key doesn't exist
    return "Link not found", 404

Now, when your affiliate network sends you a monthly conversion report CSV, it will contain that `subId` (our `click_id`). You can write a simple script to parse that file, look up the `click_id` in your database, and update the `has_converted` and `commission_amount` fields. You now have a closed-loop system.

Solution 3: The ‘Nuclear’ Option (Buy, Don’t Build)

Let’s be realistic. Building and maintaining the system above takes time. Your time as an engineer is expensive. If affiliate marketing is a core part of your business, sometimes the best engineering decision is to not engineer it at all.

There are entire companies dedicated to solving this exact problem. Services like Voluum, RedTrack, or for WordPress-centric folks, plugins like ThirstyAffiliates or Lasso, do all of this for you. They provide the redirect/cloaking service, the database, and the reporting dashboards to tie it all together.

The trade-offs are obvious:

• Pros: Saves massive amounts of development and maintenance time. Gives you sophisticated reporting tools out of the box. Quick to implement.
• Cons: It costs money (monthly subscription fees). You’re trusting a third party with your click data. It might be overkill if you only have a handful of links.

My Two Cents: Don’t reinvent the wheel if you don’t have to. Do a cost-benefit analysis. If a $99/month service saves you 10 hours of engineering time a month, it’s a no-brainer. Your time is almost always better spent building features for your core product, not a link tracker.

Ultimately, moving from zero tracking to even the simple Sub-ID method is a huge leap. Start there. If you find yourself hitting its limits, you’ll have a much better business case for dedicating engineering resources to build a proper solution or pay for a third-party one.

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions