DEV Community: Alex

Building an Automated Affiliate Analytics Dashboard with Python

Alex — Tue, 30 Jun 2026 14:37:24 +0000

Affiliate marketing usually comes with dozens of dashboards.

One network shows clicks.
Another shows conversions.
A third shows payouts.

After a while you spend more time collecting numbers than analyzing them.

As developers, we can automate almost everything.

Instead of opening five browser tabs every morning, let's build a small pipeline that collects affiliate statistics, stores them in one place, and tells us when something actually needs attention.

The Goal

We'll build a system that can:

Pull statistics from affiliate APIs
Store daily metrics
Calculate EPC and conversion rate
Alert when performance drops
Generate a simple revenue report

Nothing revolutionary.

Just removing repetitive work.

1. Collect Statistics

Most affiliate platforms expose REST APIs.

Instead of checking every dashboard manually, we can fetch the data automatically.

import requests

class AffiliateClient:
    def __init__(self, api_key):
        self.api_key = api_key

    def get_stats(self):
        response = requests.get(
            "https://api.example.com/stats",
            headers={
                "Authorization": f"Bearer {self.api_key}"
            }
        )

        response.raise_for_status()
        return response.json()

Run this every few hours with cron, GitHub Actions or a small VPS.

Now your statistics are available in code instead of locked inside a dashboard.

2. Store Historical Data

Daily snapshots become much more valuable than today's numbers.

import sqlite3
from datetime import date

db = sqlite3.connect("affiliate.db")

db.execute("""
CREATE TABLE IF NOT EXISTS stats(
    day TEXT,
    clicks INTEGER,
    conversions INTEGER,
    revenue REAL
)
""")

def save(day, clicks, conversions, revenue):
    db.execute(
        "INSERT INTO stats VALUES (?, ?, ?, ?)",
        (day, clicks, conversions, revenue)
    )
    db.commit()

A few weeks later you'll have enough history to spot trends instead of reacting to random fluctuations.

3. Calculate Useful Metrics

Raw clicks rarely tell the whole story.

def calculate(clicks, conversions, revenue):
    return {
        "conversion_rate":
            conversions / clicks if clicks else 0,
        "epc":
            revenue / clicks if clicks else 0
    }

Two numbers are usually enough:

Conversion Rate
EPC (Earnings Per Click)

Everything else is secondary.

4. Detect Problems Automatically

Instead of watching dashboards all day, let the script notify you.

def check(metrics):
    if metrics["conversion_rate"] < 0.02:
        print("⚠️ Conversion rate dropped")

    if metrics["epc"] < 0.5:
        print("⚠️ EPC below target")

Whether you send Slack messages, emails or Discord notifications doesn't matter.

The important part is learning about problems immediately instead of days later.

5. Generate Reports

Once the data lives in your database, reporting becomes trivial.

SELECT
    SUM(clicks) AS clicks,
    SUM(conversions) AS conversions,
    SUM(revenue) AS revenue
FROM stats;

Now you can build dashboards with Streamlit, Grafana or any visualization tool you prefer.

What I Learned

I used to think affiliate marketing was mostly about finding better offers.

It isn't.

A surprising amount of time disappears into repetitive reporting.

Automation doesn't magically increase revenue.

It simply gives you cleaner data, faster feedback and fewer manual tasks.

That's usually enough to make better decisions.

Because in the end, the bottleneck isn't Python.

It's how quickly you notice what's changing.

Have you automated any part of your affiliate workflow? I'd be interested to see how other developers approach it.

Affiliate Marketing for Developers

Alex — Mon, 29 Jun 2026 17:16:52 +0000

Affiliate Marketing for Developers

api #python #automation #tutorial

Automate Your Affiliate Marketing with APIs (Python Guide)

A technical guide for developers who want to build passive income streams.

Why Developers Should Care About Affiliate Marketing

Most affiliate marketers click around dashboards manually and guess what converts. As a developer, you can build automation that gives you an unfair advantage:

Automated program discovery — Find high-commission programs before your competitors
Click tracking — Know exactly which content drives conversions
Performance monitoring — Track ROI across all platforms in real-time
Revenue analytics — See what's actually making money, hands-free

Let's build these systems step by step.

1. Affiliate Program Scanner

Find the best-paying programs in any niche automatically:

import requests
from dataclasses import dataclass
from typing import List

@dataclass
class AffiliateProgram:
    name: str
    commission_rate: float
    cookie_duration: int  # days
    niche: str
    signup_url: str

class ProgramScanner:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.impact.com/Mediapartners"

    def get_programs_by_niche(self, niche: str, min_commission: float = 10.0):
        """Fetch affiliate programs filtered by niche and commission"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

        response = requests.get(
            f"{self.base_url}/Programs",
            headers=headers,
            params={
                "Category": niche,
                "MinCommission": min_commission,
                "Status": "Active"
            }
        )

        programs = response.json().get("Programs", [])
        return [self._parse_program(p) for p in programs]

    def _parse_program(self, raw) -> AffiliateProgram:
        return AffiliateProgram(
            name=raw["Name"],
            commission_rate=float(raw["DefaultPayout"]),
            cookie_duration=int(raw["CookieDuration"]),
            niche=raw["Category"],
            signup_url=raw["ApplicationUrl"]
        )

# Usage
scanner = ProgramScanner("your_impact_api_key")
programs = scanner.get_programs_by_niche("software", min_commission=20.0)

for p in programs:
    print(f"{p.name}: {p.commission_rate}% — {p.cookie_duration}d cookie")

2. Click & Conversion Tracker

Track every link across all your platforms:

import hashlib
import time
from datetime import datetime

class ConversionTracker:
    def __init__(self, db_connection):
        self.db = db_connection

    def generate_tracking_link(self, affiliate_url: str, source: str, campaign: str) -> str:
        """Wrap any affiliate link with tracking parameters"""
        click_id = hashlib.md5(
            f"{affiliate_url}{source}{time.time()}".encode()
        ).hexdigest()[:12]

        self.db.insert("clicks", {
            "click_id": click_id,
            "source": source,
            "campaign": campaign,
            "original_url": affiliate_url,
            "created_at": datetime.now().isoformat()
        })

        return f"https://yourdomain.com/go/{click_id}"

    def record_conversion(self, click_id: str, commission: float):
        """Called via webhook when a sale is confirmed"""
        click = self.db.find("clicks", {"click_id": click_id})

        if not click:
            return {"status": "error", "message": "Click not found"}

        self.db.update("clicks", click_id, {
            "converted": True,
            "commission": commission,
            "converted_at": datetime.now().isoformat()
        })

        print(f"💰 Conversion! Click {click_id} → ${commission}")
        return {"status": "success"}

# Usage
tracker = ConversionTracker(your_db)
link = tracker.generate_tracking_link(
    affiliate_url="https://partner.com/ref/abc123",
    source="blog-post",
    campaign="python-tools-june"
)
print(f"Tracking link: {link}")

3. Performance Monitor

Get daily alerts when your numbers drop:

import schedule
import time
from typing import Dict

class PerformanceMonitor:
    def __init__(self, alert_threshold: float = 0.02):
        self.alert_threshold = alert_threshold
        self.programs: Dict[str, dict] = {}

    def add_program(self, name: str, program_id: str):
        self.programs[name] = {
            "id": program_id,
            "clicks": 0,
            "conversions": 0,
            "revenue": 0.0
        }

    def check_performance(self):
        """Run daily to flag underperforming programs"""
        print("📊 Running performance check...")

        for name, data in self.programs.items():
            stats = self.fetch_stats(data["id"])
            conv_rate = stats["conversions"] / stats["clicks"] if stats["clicks"] > 0 else 0

            if conv_rate < self.alert_threshold:
                self.send_alert(name, conv_rate)
                print(f"⚠️  LOW PERFORMANCE: {name}")
                print(f"   Rate: {conv_rate:.1%} (Min: {self.alert_threshold:.1%})")
            else:
                print(f"✅ {name}: {conv_rate:.1%} — Looking good!")

    def fetch_stats(self, program_id: str) -> dict:
        pass

    def send_alert(self, program_name: str, rate: float):
        pass

# Setup
monitor = PerformanceMonitor(alert_threshold=0.03)
monitor.add_program("Hostinger", "prog_001")
monitor.add_program("Notion", "prog_002")

schedule.every().day.at("08:00").do(monitor.check_performance)

while True:
    schedule.run_pending()
    time.sleep(60)

4. Revenue Analyzer

Figure out which content actually earns:


python
from collections import defaultdict

class RevenueAnalyzer:
    def __init__(self, clicks_data: list):
        self.data = clicks_data

    def analyze_by_source(self) -> dict:
        """Which traffic source drives the most revenue?"""
        sources = defaultdict(lambda: {"clicks": 0, "revenue": 0.0})

        for click in self.data:
            src = click["source"]
            sources[src]["clicks"] += 1
            if click.get("converted"):
                sources[src]["revenue"] += click["commission"]

        for src in sources:
            clicks = sources[src]["clicks"]
            revenue = sources[src]["revenue"]
            sources[src]["epc"] = revenue / clicks if clicks > 0 else 0
            sources[src]["score"] = self._score(sources[src])

        return dict(sorted(sources.items(), key=lambda x: x[1]["score"], reverse=True))

    def _score(self, data: dict) -> int:
        score = 0
        if data["epc"] > 2.0:
            score += 40
        elif data["epc"] > 1.0:
            score += 25
        elif data["epc"] > 0.5:
            score += 10
        if data["revenue"] > 500:
            score += 40
        elif data["revenue"] > 100:
            score += 25
        if data["clicks"] > 1000:
            score += 20
        return score

    def get_recommendation(self, score: int) -> str:
        if score >= 70:
            return "🟢 SCALE IT — Double down on this source"
        elif score >= 50:
            return "🟡 OPTIMIZE

Dropshipping for Developers

Alex — Sun, 28 Jun 2026 01:58:23 +0000

Automate Your Dropshipping Business with APIs (Python Guide)

A technical guide for developers who want to build passive income streams.

Why Developers Should Care About Dropshipping

Most dropshippers use Shopify apps and manual processes. As a developer, you can build custom automation that gives you an unfair advantage:

Automated product research — Find winning products before anyone else
Price monitoring — Track competitor pricing in real-time
Order automation — Forward orders to suppliers instantly
Analytics dashboards — Track what's actually making money

Let's build these systems step by step.

1. Product Research API

First, let's create a script that finds trending products:

import requests
from datetime import datetime

class ProductResearcher:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.shopify.com/storefront"

    def get_trending_products(self, niche, limit=50):
        """Fetch trending products in a specific niche"""
        query = """
        {
          products(first: %d, query: "tag:%s") {
            edges {
              node {
                title
                priceRange {
                  minVariantPrice {
                    amount
                    currencyCode
                  }
                }
                images(first: 1) {
                  edges {
                    node {
                      url
                    }
                  }
                }
              }
            }
          }
        }
        """ % (limit, niche)

        headers = {
            "X-Shopify-Storefront-Access-Token": self.api_key,
            "Content-Type": "application/json"
        }

        response = requests.post(
            f"{self.base_url}/graphql.json",
            json={"query": query},
            headers=headers
        )

        return response.json()

# Usage
researcher = ProductResearcher("your_storefront_token")
products = researcher.get_trending_products("pet-supplies")

2. Price Monitoring System

Track competitor prices and alert when they drop:

import schedule
import time
from dataclasses import dataclass
from typing import List

@dataclass
class PriceAlert:
    product_name: str
    current_price: float
    target_price: float
    url: str

class PriceMonitor:
    def __init__(self):
        self.alerts: List[PriceAlert] = []

    def add_alert(self, product_name, target_price, url):
        self.alerts.append(PriceAlert(
            product_name=product_name,
            current_price=0,
            target_price=target_price,
            url=url
        ))

    def check_prices(self):
        """Run every hour to check prices"""
        for alert in self.alerts:
            current = self.fetch_price(alert.url)
            alert.current_price = current

            if current <= alert.target_price:
                self.send_notification(alert)
                print(f"🚨 PRICE DROP: {alert.product_name}")
                print(f"   Now: ${current} (Target: ${alert.target_price})")

    def fetch_price(self, url):
        # Implement your scraping/API logic here
        pass

    def send_notification(self, alert):
        # Send Slack/email notification
        pass

# Setup
monitor = PriceMonitor()
monitor.add_alert("Pet Grooming Kit", 15.00, "https://supplier.com/product/123")

# Run every hour
schedule.every(1).hours.do(monitor.check_prices)

while True:
    schedule.run_pending()
    time.sleep(60)

3. Order Automation Script

Automatically forward orders to your supplier:

import hashlib
import hmac
import json
from datetime import datetime

class OrderAutomation:
    def __init__(self, supplier_api_key, supplier_secret):
        self.api_key = supplier_api_key
        self.secret = supplier_secret

    def process_order(self, order_data):
        """Process incoming Shopify order and forward to supplier"""

        # Validate order
        if not self.validate_order(order_data):
            return {"status": "error", "message": "Invalid order"}

        # Format for supplier API
        supplier_order = {
            "order_id": order_data["id"],
            "customer": {
                "name": order_data["shipping_address"]["name"],
                "email": order_data["email"],
                "address": order_data["shipping_address"]
            },
            "items": [
                {
                    "sku": item["sku"],
                    "quantity": item["quantity"],
                    "price": item["price"]
                }
                for item in order_data["line_items"]
            ],
            "timestamp": datetime.now().isoformat()
        }

        # Send to supplier
        response = self.send_to_supplier(supplier_order)

        # Update Shopify with tracking
        if response["status"] == "success":
            self.update_shopify_tracking(
                order_data["id"],
                response["tracking_number"]
            )

        return response

    def validate_order(self, order):
        required_fields = ["id", "email", "shipping_address", "line_items"]
        return all(field in order for field in required_fields)

    def send_to_supplier(self, order):
        # Implement API call to your supplier
        print(f"📦 Forwarding order {order['order_id']} to supplier")
        return {"status": "success", "tracking_number": "TRACK123"}

    def update_shopify_tracking(self, order_id, tracking_number):
        # Update order in Shopify with tracking info
        print(f"✅ Updated order {order_id} with tracking: {tracking_number}")

4. Niche Analysis Tool

Find profitable niches using data:

import requests
from collections import Counter

class NicheAnalyzer:
    def __init__(self):
        self.trends_api = "https://trends.google.com/trends/api"

    def analyze_niche(self, keyword):
        """Analyze search trends for a niche"""

        # Get search volume data
        search_data = self.get_search_volume(keyword)

        # Calculate score
        score = self.calculate_profitability_score(search_data)

        return {
            "keyword": keyword,
            "search_volume": search_data["volume"],
            "competition": search_data["competition"],
            "trend": search_data["trend"],
            "profitability_score": score,
            "recommendation": self.get_recommendation(score)
        }

    def calculate_profitability_score(self, data):
        """Score from 0-100 based on multiple factors"""
        score = 0

        # Search volume (0-30 points)
        if data["volume"] > 100000:
            score += 30
        elif data["volume"] > 50000:
            score += 20
        elif data["volume"] > 10000:
            score += 10

        # Competition (0-30 points, lower is better)
        if data["competition"] < 0.3:
            score += 30
        elif data["competition"] < 0.5:
            score += 20
        elif data["competition"] < 0.7:
            score += 10

        # Trend direction (0-40 points)
        if data["trend"] == "rising":
            score += 40
        elif data["trend"] == "stable":
            score += 20

        return score

    def get_recommendation(self, score):
        if score >= 70:
            return "🟢 STRONG - High potential niche"
        elif score >= 50:
            return "🟡 MODERATE - Worth testing"
        elif score >= 30:
            return "🟠 WEAK - Consider alternatives"
        else:
            return "🔴 AVOID - Too competitive or low demand"

# Usage
analyzer = NicheAnalyzer()
results = [
    analyzer.analyze_niche("pet supplies"),
    analyzer.analyze_niche("home fitness"),
    analyzer.analyze_niche("smart home"),
]

for result in results:
    print(f"\n{result['keyword'].upper()}")
    print(f"Score: {result['profitability_score']}/100")
    print(f"Recommendation: {result['recommendation']}")

5. Putting It All Together

Here's how to combine everything into a single automation system:

class DropshippingAutomation:
    def __init__(self):
        self.researcher = ProductResearcher("token")
        self.monitor = PriceMonitor()
        self.orders = OrderAutomation("key", "secret")
        self.analyzer = NicheAnalyzer()

    def daily_routine(self):
        """Run daily automation tasks"""
        print("🌅 Starting daily automation...")

        # 1. Research new products
        print("\n📊 Researching trending products...")
        products = self.researcher.get_trending_products("pet-supplies")

        # 2. Analyze niches
        print("\n🔍 Analyzing niche profitability...")
        niches = ["pet supplies", "home fitness", "sustainable goods"]
        for niche in niches:
            result = self.analyzer.analyze_niche(niche)
            print(f"  {result['keyword']}: {result['profitability_score']}/100")

        # 3. Check prices
        print("\n💰 Checking price alerts...")
        self.monitor.check_prices()

        print("\n✅ Daily automation complete!")

# Run the system
automation = DropshippingAutomation()
automation.daily_routine()

DEV Community: Alex

Building an Automated Affiliate Analytics Dashboard with Python

The Goal

1. Collect Statistics

2. Store Historical Data

3. Calculate Useful Metrics

4. Detect Problems Automatically

5. Generate Reports

What I Learned

Affiliate Marketing for Developers

api #python #automation #tutorial

Automate Your Affiliate Marketing with APIs (Python Guide)

Why Developers Should Care About Affiliate Marketing

1. Affiliate Program Scanner

2. Click & Conversion Tracker

3. Performance Monitor

4. Revenue Analyzer

Dropshipping for Developers

Automate Your Dropshipping Business with APIs (Python Guide)

Why Developers Should Care About Dropshipping

1. Product Research API

2. Price Monitoring System

3. Order Automation Script

4. Niche Analysis Tool

5. Putting It All Together

Next Steps

Want More?