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
