DEV Community: Md Romjan Ali

Django-Clickify: The Complete Click Tracking Solution for Django

Md Romjan Ali — Sat, 06 Sep 2025 15:35:51 +0000

Introduction

Ever wanted to track clicks on your affiliate links, monitor file downloads, or analyze outbound traffic from your Django application? If you've tried building this functionality from scratch, you know it quickly becomes complex when you need features like rate limiting, IP filtering, and geolocation.

Django-Clickify solves all these problems with a simple, powerful package that transforms any URL into a trackable link with just a few lines of code.

What is Django-Clickify?

Django-Clickify is a comprehensive click tracking solution for Django that logs every click on your tracked links, complete with IP address, user agent, timestamp, and even geographical location. It's perfect for:

📈 Affiliate Marketing: Track clicks on affiliate links
📁 File Downloads: Monitor who's downloading your content
🔗 Outbound Links: Analyze external traffic patterns
📊 Campaign Analytics: Measure marketing campaign effectiveness

Key Features

🎯 Complete Click Tracking: IP address, user agent, timestamp, and more
🌍 Automatic Geolocation: Country and city detection for each click
🛡️ Built-in Rate Limiting: Prevent abuse and bot traffic
🚫 IP Filtering: Allowlists and blocklists for fine-grained control
🔧 Django Admin Integration: Manage links through familiar interface
🚀 Dual Usage Modes: Template tags AND REST API support
⚡ Production Ready: Handles proxies, load balancers, and CDNs

Installation & Setup

Step 1: Install the Package

# Basic installation
pip install django-clickify

# With all optional features (recommended)
pip install django-clickify[full]

# Or install specific features only
pip install django-clickify[ratelimit]  # Rate limiting only
pip install django-clickify[drf]        # API support only

Step 2: Configure Django Settings

Add to your INSTALLED_APPS:

# settings.py
INSTALLED_APPS = [
    # ... your other apps
    'clickify',
    'rest_framework',  # Only if using API features
]

Step 3: Run Migrations

python manage.py migrate

This creates the database tables needed to store your tracked links and click data.

Basic Configuration

Django-Clickify works great out of the box, but here are the key settings you might want to customize:

# settings.py

# Geolocation (enabled by default)
CLICKIFY_GEOLOCATION = True

# Rate limiting (5 clicks per minute by default)
CLICKIFY_ENABLE_RATELIMIT = True
CLICKIFY_RATE_LIMIT = '5/m'
CLICKIFY_RATELIMIT_MESSAGE = "Too many requests. Please try again later."

# IP filtering
CLICKIFY_IP_ALLOWLIST = []  # Always allowed IPs
CLICKIFY_IP_BLOCKLIST = []  # Always blocked IPs

# For apps behind proxies/CDNs
CLICKIFY_IP_HEADERS = [
    "HTTP_CF_CONNECTING_IP",    # Cloudflare
    "HTTP_X_FORWARDED_FOR",     # Standard proxy
    "HTTP_X_REAL_IP",           # Nginx
    "REMOTE_ADDR",              # Fallback
]

Creating Your First Tracked Link

Using Django Admin

Go to your Django Admin interface
Navigate to the "Clickify" section
Click "Add Tracked Link"
Fill in the details:
- Name: Download Our App
- Slug: download-app (auto-generated)
- Target URL: https://play.google.com/store/apps/details?id=com.yourapp

That's it! Your tracked link is ready to use.

Usage Method 1: Template Tags (Traditional Django)

Perfect for server-rendered Django templates and most common use cases.

Step 1: Configure URLs

# urls.py
from django.urls import path, include

urlpatterns = [
    # ... your other URLs
    path('go/', include('clickify.urls', namespace='clickify')),
]

Step 2: Use in Templates

<!-- your_template.html -->
{% load clickify_tags %}

<div class="download-section">
    <h2>Get Our Mobile App</h2>
    <a href="{% track_url 'download-app' %}" class="btn btn-primary">
        Download Now
    </a>
</div>

<!-- Multiple tracked links -->
<div class="links">
    <a href="{% track_url 'affiliate-product-1' %}">Special Offer 1</a>
    <a href="{% track_url 'affiliate-product-2' %}">Special Offer 2</a>
    <a href="{% track_url 'monthly-report-pdf' %}">Download Report</a>
</div>

Step 3: Handle Rate Limiting Messages

<!-- Display rate limiting messages -->
{% if messages %}
<div class="messages">
    {% for message in messages %}
    <div class="alert alert-{{ message.tags }}">
        {{ message }}
    </div>
    {% endfor %}
</div>
{% endif %}

Usage Method 2: REST API (Modern JS Frameworks)

Perfect for React, Vue, Angular, or any JavaScript-heavy application.

Step 1: Configure API URLs

# urls.py
from django.urls import path, include

urlpatterns = [
    # ... your other URLs
    path('api/track/', include('clickify.drf_urls', namespace='clickify-api')),
]

Step 2: Track Clicks with JavaScript

// Modern async/await approach
async function trackClick(slug) {
    try {
        const response = await fetch(`/api/track/${slug}/`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'X-CSRFToken': getCsrfToken(), // Your CSRF token function
            },
        });

        const data = await response.json();

        if (response.ok) {
            // Click tracked successfully
            window.location.href = data.target_url;
        } else {
            // Handle rate limiting or other errors
            alert(data.error);
        }
    } catch (error) {
        console.error('Tracking failed:', error);
    }
}

// Usage in your components
document.getElementById('download-btn').addEventListener('click', (e) => {
    e.preventDefault();
    trackClick('download-app');
});

React Component Example

// DownloadButton.jsx
import { useState } from 'react';

function DownloadButton({ slug, children }) {
    const [isLoading, setIsLoading] = useState(false);

    const handleClick = async (e) => {
        e.preventDefault();
        setIsLoading(true);

        try {
            const response = await fetch(`/api/track/${slug}/`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'X-CSRFToken': getCsrfToken(),
                },
            });

            const data = await response.json();

            if (response.ok) {
                window.location.href = data.target_url;
            } else {
                alert(data.error);
            }
        } catch (error) {
            console.error('Error:', error);
        } finally {
            setIsLoading(false);
        }
    };

    return (
        <button onClick={handleClick} disabled={isLoading}>
            {isLoading ? 'Processing...' : children}
        </button>
    );
}

// Usage
<DownloadButton slug="download-app">
    Download Our App
</DownloadButton>

Advanced Features

IP Filtering with Middleware

Enable sophisticated IP-based access control:

# settings.py
MIDDLEWARE = [
    # ... other middleware
    'clickify.middleware.IPFilterMiddleware',
    # ... rest of middleware
]

# Configure IP filtering
CLICKIFY_IP_ALLOWLIST = ['192.168.1.100', '10.0.0.0/8']
CLICKIFY_IP_BLOCKLIST = ['192.168.1.50']

Custom Rate Limiting

Fine-tune rate limiting for your use case:

# settings.py

# Conservative: 2 clicks per hour
CLICKIFY_RATE_LIMIT = '2/h'

# Moderate: 10 clicks per minute  
CLICKIFY_RATE_LIMIT = '10/m'

# Generous: 100 clicks per hour
CLICKIFY_RATE_LIMIT = '100/h'

# Disable rate limiting entirely
CLICKIFY_ENABLE_RATELIMIT = False

API Permission Control

Secure your tracking API:

# settings.py
CLICKIFY_PERMISSION_CLASSES = [
    "rest_framework.permissions.IsAuthenticated"
]

# Custom exception handling for better API responses
REST_FRAMEWORK = {
    'EXCEPTION_HANDLER': 'clickify.drf_exception_handler.custom_exception_handler'
}

Real-World Example: E-commerce Affiliate Tracking

Let's build a complete affiliate link tracking system for an e-commerce site.

Step 1: Create Tracked Links in Admin

Create these tracked links:

Name: Amazon Product 1, Slug: amazon-product-1
Name: eBay Special Deal, Slug: ebay-special-deal
Name: Shopify Partner Link, Slug: shopify-partner

Step 2: Products Template

<!-- products.html -->
{% load clickify_tags %}

<div class="products-grid">
    {% for product in products %}
    <div class="product-card">
        <img src="{{ product.image }}" alt="{{ product.name }}">
        <h3>{{ product.name }}</h3>
        <p class="price">${{ product.price }}</p>

        <!-- Tracked affiliate link -->
        <a href="{% track_url product.affiliate_slug %}" 
           class="btn btn-primary"
           target="_blank">
            Buy Now - Best Price!
        </a>
    </div>
    {% endfor %}
</div>

<!-- Rate limiting message display -->
{% if messages %}
<div class="alert-container">
    {% for message in messages %}
    <div class="alert alert-warning">
        {{ message }}
    </div>
    {% endfor %}
</div>
{% endif %}

Step 3: View Logic

# views.py
from django.shortcuts import render

def products_view(request):
    products = [
        {
            'name': 'Wireless Headphones',
            'price': 99.99,
            'image': '/static/images/headphones.jpg',
            'affiliate_slug': 'amazon-product-1'
        },
        {
            'name': 'Smart Watch',
            'price': 199.99,
            'image': '/static/images/watch.jpg',
            'affiliate_slug': 'ebay-special-deal'
        },
    ]

    return render(request, 'products.html', {'products': products})

Step 4: Analytics Dashboard

Access click analytics through Django Admin, or build a custom dashboard:

# analytics_views.py
from django.shortcuts import render
from clickify.models import TrackedLink, ClickLog
from django.db.models import Count
from django.utils import timezone
from datetime import timedelta

def analytics_dashboard(request):
    # Get click stats for last 30 days
    thirty_days_ago = timezone.now() - timedelta(days=30)

    stats = ClickLog.objects.filter(
        timestamp__gte=thirty_days_ago
    ).values(
        'tracked_link__name'
    ).annotate(
        click_count=Count('id')
    ).order_by('-click_count')

    # Top countries
    countries = ClickLog.objects.filter(
        timestamp__gte=thirty_days_ago,
        country__isnull=False
    ).values('country').annotate(
        count=Count('id')
    ).order_by('-count')[:10]

    context = {
        'link_stats': stats,
        'top_countries': countries,
        'total_clicks': ClickLog.objects.filter(timestamp__gte=thirty_days_ago).count()
    }

    return render(request, 'analytics.html', context)

Production Deployment Tips

1. Geolocation Performance

For high-traffic sites, consider caching geolocation results:

# settings.py
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/1',
    }
}

2. Database Optimization

Add indexes for better query performance:

# In your custom migration or model
class Meta:
    indexes = [
        models.Index(fields=['timestamp']),
        models.Index(fields=['ip_address']),
        models.Index(fields=['tracked_link', 'timestamp']),
    ]

3. CDN and Proxy Configuration

For Cloudflare or AWS CloudFront:

# settings.py
CLICKIFY_IP_HEADERS = [
    "HTTP_CF_CONNECTING_IP",      # Cloudflare
    "HTTP_X_FORWARDED_FOR",       # AWS ALB/ELB
    "HTTP_X_REAL_IP",             # Nginx
    "REMOTE_ADDR",                # Fallback
]

Common Use Cases

1. Newsletter Link Tracking

Track which newsletter links get the most clicks:

{% load clickify_tags %}
<a href="{% track_url 'newsletter-cta-button' %}">Read Full Article</a>

2. Social Media Campaign Tracking

Create unique tracked links for each platform:

facebook-campaign-q4
twitter-promo-black-friday
instagram-story-link

3. File Download Analytics

Track PDF downloads, software downloads, etc.:

<a href="{% track_url 'whitepaper-download' %}" download>
    Download Whitepaper (PDF)
</a>

4. A/B Testing Link Performance

Create two tracked links pointing to the same destination to test different call-to-action text.

Troubleshooting

Rate Limiting Not Working

Make sure you have django-ratelimit installed:

pip install django-ratelimit

Geolocation Not Working

Check your internet connection and ensure the geolocation API is accessible.

API Permissions Issues

Verify your CLICKIFY_PERMISSION_CLASSES setting and ensure proper authentication.

Missing Click Data

Check that your CLICKIFY_IP_HEADERS are correctly configured for your deployment setup.

What Makes Django-Clickify Special?

Unlike simple URL shorteners or basic click counters, Django-Clickify provides:

Enterprise-grade features out of the box
Flexible deployment options (template tags + API)
Built-in security (rate limiting, IP filtering)
Rich analytics data (geolocation, user agents)
Production-ready architecture

Whether you're running a small blog with affiliate links or a large e-commerce platform tracking millions of clicks, Django-Clickify scales to meet your needs.

Conclusion

Django-Clickify transforms the complex task of click tracking into a simple, powerful solution. With just a few lines of configuration, you get professional-grade analytics, security features, and flexible usage options.

The combination of template tags for traditional Django apps and REST API for modern JavaScript frameworks means you can use it in any Django project, regardless of your frontend architecture.

Get Started Today

📦 Install: pip install django-clickify[full]
📚 Documentation: Check the GitHub repository
🐙 Source Code: GitHub
📈 PyPI Package: django-clickify on PyPI

Have you implemented click tracking in your Django projects? Share your experience and use cases in the comments below!

Optimize Django Queries: Unmasking and Solving the N+1 Problem (Interactive Guide)

Md Romjan Ali — Tue, 11 Mar 2025 23:15:49 +0000

Is your Django application feeling sluggish, especially when dealing with related data? You're not alone. Many developers, especially those new to Django, encounter the notorious N+1 query problem. In this post, we will dive deep into the issue, understand its impact, and learn how to fix it using select_related and prefetch_related.

This will be interactive. Feel free to answer the questions in the comments and share your thoughts.

What is the N+1 Problem?

Imagine you have a blog application where each Post has an associated Author. You want to display a list of blog posts along with their authors.

A naive implementation might look like this:

posts = Post.objects.all()
for post in posts:
    print(f"Post: {post.title}, Author: {post.author.name}")

Question 1: What do you think is happening behind the scenes with the database queries?

Take a moment to think about it.

If you guessed "too many queries," you are correct. Here's what happens:

First query: Post.objects.all() retrieves all posts.
Subsequent queries: For each post, a separate query is executed to fetch the author.name.

For N posts, this results in N+1 queries: one for fetching posts and N additional queries for fetching authors. If you have 100 posts, this leads to 101 queries.

Why is the N+1 Problem a Big Deal?

The N+1 problem can severely impact your application’s performance. Here’s why:

Increased Latency: Your application takes longer to respond due to multiple database queries.
Higher Database Load: Unoptimized queries put unnecessary strain on your database.
Poor User Experience: Slow loading times lead to frustration and potential user drop-off.

Question 2: How do you think we can optimize this?

Let’s explore Django’s solutions.

The Solution: select_related and prefetch_related

Django provides two powerful tools to fix the N+1 problem:

1.`select_related()`

Best for ForeignKey and OneToOne relationships.
Performs a single SQL JOIN query to retrieve related objects in one go.
Example:

posts = Post.objects.select_related('author').all()
for post in posts:
    print(f"Post: {post.title}, Author: {post.author.name}")

This reduces the number of queries to just one.

2. `prefetch_related()`

Best for ManyToMany and reverse ForeignKey relationships.
Performs separate queries for related objects but caches them for efficiency.
Example:

authors = Author.objects.prefetch_related('post_set').all()
for author in authors:
    for post in author.post_set.all():
        print(f"Author: {author.name}, Post: {post.title}")

This reduces redundant queries while keeping flexibility.

Hands-On Challenge

Let’s put theory into practice. Try the following:

Create a simple Django project with Author and Post models.
Populate your database with sample data.
Write code that exhibits the N+1 problem.
Use select_related and prefetch_related to optimize it.
Use Django Debug Toolbar to compare query counts.
Share your findings in the comments.

Conclusion

The N+1 problem is a common performance bottleneck, but understanding and using select_related and prefetch_related can drastically improve your Django application's efficiency.

Final Question: What other performance optimization techniques do you use in Django? Share your tips below.

If you found this post helpful, leave a comment, share it, and follow for more Django insights.

DEV Community: Md Romjan Ali

Django-Clickify: The Complete Click Tracking Solution for Django

Introduction

What is Django-Clickify?

Key Features

Installation & Setup

Step 1: Install the Package

Step 2: Configure Django Settings

Step 3: Run Migrations

Basic Configuration

Creating Your First Tracked Link

Using Django Admin

Usage Method 1: Template Tags (Traditional Django)

Step 1: Configure URLs

Step 2: Use in Templates

Step 3: Handle Rate Limiting Messages

Usage Method 2: REST API (Modern JS Frameworks)

Step 1: Configure API URLs

Step 2: Track Clicks with JavaScript

React Component Example

Advanced Features

IP Filtering with Middleware

Custom Rate Limiting

API Permission Control

Real-World Example: E-commerce Affiliate Tracking

Step 1: Create Tracked Links in Admin

Step 2: Products Template

Step 3: View Logic

Step 4: Analytics Dashboard

Production Deployment Tips

1. Geolocation Performance

2. Database Optimization

3. CDN and Proxy Configuration

Common Use Cases

1. Newsletter Link Tracking

2. Social Media Campaign Tracking

3. File Download Analytics

4. A/B Testing Link Performance

Troubleshooting

Rate Limiting Not Working

Geolocation Not Working

API Permissions Issues

Missing Click Data

What Makes Django-Clickify Special?

Conclusion

Get Started Today

Optimize Django Queries: Unmasking and Solving the N+1 Problem (Interactive Guide)

What is the N+1 Problem?

Question 1: What do you think is happening behind the scenes with the database queries?

Why is the N+1 Problem a Big Deal?

Question 2: How do you think we can optimize this?

1.select_related()

2. prefetch_related()

Hands-On Challenge

Conclusion

1.`select_related()`

2. `prefetch_related()`