Monitoring ShopeeFood Pricing and Promotions with Proxies

ShopeeFood, part of the Shopee ecosystem owned by Sea Limited, has rapidly expanded its food delivery operations across Southeast Asia. The platform’s integration with Shopee’s e-commerce infrastructure means it frequently runs promotions, dynamic pricing, and cross-platform deals that create valuable intelligence opportunities for F&B businesses and market researchers.

This guide covers how to build a systematic monitoring pipeline for ShopeeFood pricing and promotional data using proxy infrastructure.

Why Monitor ShopeeFood Pricing?

ShopeeFood’s pricing landscape is complex and constantly shifting. Understanding these dynamics gives businesses a significant competitive edge.

Dynamic Pricing Patterns

ShopeeFood adjusts pricing based on multiple factors:

Time of day: Lunch and dinner rush pricing differs from off-peak hours
Day of week: Weekend pricing often includes different promotions
Weather conditions: Rainy day surcharges on delivery fees
Demand levels: High-demand areas may see adjusted delivery fees
Promotional campaigns: Platform-wide and restaurant-specific discounts

Promotional Complexity

ShopeeFood runs several types of promotions simultaneously:

Platform-wide voucher codes
Restaurant-specific discounts
Free delivery thresholds
Bundle deals and combo pricing
Shopee Coins cashback offers
Flash sale events tied to Shopee campaigns (9.9, 11.11, 12.12)

Tracking all these manually is impossible, making automated monitoring essential.

ShopeeFood’s Technical Architecture

Platform Structure

ShopeeFood operates through both its mobile app and web interface. The web version runs on a JavaScript framework that makes API calls to backend services for data retrieval.

Key technical characteristics:

API-driven content loading: Menu and pricing data loaded via REST APIs
Session-based authentication: Some endpoints require valid user sessions
Location dependency: All content filtered by user location
Shopee ecosystem integration: Shares authentication and payment systems with Shopee

Anti-Bot Measures

ShopeeFood inherits Shopee’s security infrastructure, which includes:

IP reputation scoring
Device fingerprinting
Request pattern analysis
CAPTCHA challenges for suspicious traffic
TLS fingerprint verification

Setting Up Price Monitoring

Infrastructure Requirements

For reliable ShopeeFood monitoring, you need:

Mobile proxies with SEA coverage (essential for avoiding detection)
A scheduling system for regular data collection
Storage for time-series pricing data
Alerting for significant price changes

Proxy Configuration

ShopeeFood’s detection systems are tuned to identify non-mobile traffic. Using DataResearchTools mobile proxies ensures your monitoring traffic blends with genuine ShopeeFood users.

import requests
import json
from datetime import datetime

class ShopeeeFoodMonitor:
    def __init__(self, country="SG"):
        self.country = country
        self.base_url = self._get_base_url(country)
        self.session = requests.Session()
        self._configure_proxy(country)
        self._set_headers()

    def _get_base_url(self, country):
        urls = {
            "SG": "https://shopeefood.sg",
            "MY": "https://shopeefood.my",
            "TH": "https://shopeefood.co.th",
            "ID": "https://shopeefood.co.id",
            "PH": "https://shopeefood.ph",
            "VN": "https://shopeefood.vn"
        }
        return urls.get(country, urls["SG"])

    def _configure_proxy(self, country):
        proxy_host = f"{country.lower()}-mobile.dataresearchtools.com"
        self.session.proxies = {
            "http": f"http://user:pass@{proxy_host}:8080",
            "https": f"http://user:pass@{proxy_host}:8080"
        }

    def _set_headers(self):
        self.session.headers.update({
            "User-Agent": "Mozilla/5.0 (Linux; Android 14; SM-S911B) AppleWebKit/537.36",
            "Accept": "application/json",
            "Accept-Language": "en-US,en;q=0.9",
            "Referer": self.base_url
        })

Monitoring Restaurant Pricing

Tracking Menu Price Changes

Set up regular snapshots of restaurant menus to detect price changes:

def capture_menu_snapshot(self, restaurant_id):
    """Capture a point-in-time snapshot of a restaurant's menu."""
    response = self.session.get(
        f"{self.base_url}/api/v1/restaurants/{restaurant_id}/menu"
    )

    if response.status_code != 200:
        return None

    menu_data = response.json()
    snapshot = {
        "restaurant_id": restaurant_id,
        "timestamp": datetime.utcnow().isoformat(),
        "country": self.country,
        "items": []
    }

    for category in menu_data.get("menu_categories", []):
        for item in category.get("items", []):
            snapshot["items"].append({
                "item_id": item.get("id"),
                "name": item.get("name"),
                "original_price": item.get("original_price"),
                "current_price": item.get("price"),
                "discount_percentage": item.get("discount_percent", 0),
                "available": item.get("is_available", True),
                "category": category.get("name")
            })

    return snapshot

Detecting Price Changes

Compare snapshots to identify pricing movements:

def detect_price_changes(current_snapshot, previous_snapshot):
    """Compare two snapshots to find price changes."""
    changes = []

    prev_prices = {
        item["item_id"]: item
        for item in previous_snapshot["items"]
    }

    for item in current_snapshot["items"]:
        item_id = item["item_id"]
        if item_id in prev_prices:
            prev = prev_prices[item_id]
            if item["current_price"] != prev["current_price"]:
                changes.append({
                    "item_id": item_id,
                    "item_name": item["name"],
                    "old_price": prev["current_price"],
                    "new_price": item["current_price"],
                    "change_percent": round(
                        (item["current_price"] - prev["current_price"])
                        / prev["current_price"] * 100, 2
                    ),
                    "detected_at": current_snapshot["timestamp"]
                })

    return changes

Tracking Promotions and Vouchers

Voucher Discovery

ShopeeFood displays available vouchers on restaurant pages and through promotional endpoints:

def get_available_vouchers(self, latitude, longitude):
    """Fetch currently available vouchers for a location."""
    params = {
        "lat": latitude,
        "lng": longitude,
        "voucher_type": "all"
    }

    response = self.session.get(
        f"{self.base_url}/api/v1/vouchers",
        params=params
    )

    if response.status_code != 200:
        return []

    voucher_data = response.json()
    vouchers = []

    for v in voucher_data.get("vouchers", []):
        vouchers.append({
            "code": v.get("code"),
            "description": v.get("description"),
            "discount_type": v.get("discount_type"),  # percentage, fixed
            "discount_value": v.get("discount_value"),
            "min_order": v.get("min_order_value"),
            "max_discount": v.get("max_discount"),
            "valid_from": v.get("start_time"),
            "valid_until": v.get("end_time"),
            "usage_limit": v.get("usage_limit"),
            "applicable_restaurants": v.get("restaurant_ids", [])
        })

    return vouchers

Promotion Type Classification

Categorize promotions for better analysis:

def classify_promotion(promotion):
    """Classify a promotion by type and value."""
    promo_type = promotion.get("discount_type", "unknown")
    value = promotion.get("discount_value", 0)

    if promo_type == "free_delivery":
        return {"category": "delivery", "effective_value": "variable"}
    elif promo_type == "percentage":
        max_discount = promotion.get("max_discount", float("inf"))
        return {"category": "percentage_off", "effective_value": f"{value}% up to {max_discount}"}
    elif promo_type == "fixed":
        return {"category": "fixed_discount", "effective_value": f"{value} off"}
    elif promo_type == "cashback":
        return {"category": "coins_cashback", "effective_value": f"{value} coins"}
    else:
        return {"category": "other", "effective_value": str(value)}

Delivery Fee Monitoring

Delivery fees on ShopeeFood vary by distance, time, and demand. Systematic monitoring reveals pricing patterns:

def monitor_delivery_fees(self, restaurant_id, delivery_address_coords, intervals_per_day=12):
    """Monitor delivery fee changes throughout the day."""
    import schedule
    import time

    fee_log = []

    def check_fee():
        response = self.session.get(
            f"{self.base_url}/api/v1/delivery-fee",
            params={
                "restaurant_id": restaurant_id,
                "lat": delivery_address_coords[0],
                "lng": delivery_address_coords[1]
            }
        )
        if response.status_code == 200:
            data = response.json()
            fee_log.append({
                "timestamp": datetime.utcnow().isoformat(),
                "delivery_fee": data.get("delivery_fee"),
                "surge_multiplier": data.get("surge_multiplier", 1.0),
                "estimated_time": data.get("estimated_delivery_minutes"),
                "free_delivery_threshold": data.get("free_delivery_min_order")
            })

    return fee_log

Building a Monitoring Dashboard

Data Aggregation

Aggregate monitoring data for meaningful insights:

def generate_daily_report(price_changes, vouchers, delivery_fees):
    """Generate a daily monitoring report."""
    report = {
        "date": datetime.utcnow().strftime("%Y-%m-%d"),
        "summary": {
            "total_price_changes": len(price_changes),
            "price_increases": len([c for c in price_changes if c["change_percent"] > 0]),
            "price_decreases": len([c for c in price_changes if c["change_percent"] < 0]),
            "active_vouchers": len(vouchers),
            "avg_delivery_fee": sum(f["delivery_fee"] for f in delivery_fees) / len(delivery_fees) if delivery_fees else 0,
            "peak_surge": max((f["surge_multiplier"] for f in delivery_fees), default=1.0)
        },
        "notable_changes": [
            c for c in price_changes if abs(c["change_percent"]) > 10
        ],
        "best_vouchers": sorted(vouchers, key=lambda v: v.get("discount_value", 0), reverse=True)[:5]
    }
    return report

Visualization

Create visual representations of pricing trends:

import matplotlib.pyplot as plt
import pandas as pd

def plot_price_trend(item_name, price_history):
    """Plot price history for a specific menu item."""
    df = pd.DataFrame(price_history)
    df["timestamp"] = pd.to_datetime(df["timestamp"])
    df = df.sort_values("timestamp")

    plt.figure(figsize=(12, 6))
    plt.plot(df["timestamp"], df["price"], marker="o", linewidth=2)
    plt.title(f"Price Trend: {item_name}")
    plt.xlabel("Date")
    plt.ylabel("Price")
    plt.grid(True, alpha=0.3)
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.savefig(f"price_trend_{item_name.replace(' ', '_')}.png")
    plt.close()

Multi-Country Monitoring Strategy

ShopeeFood operates differently across markets. Your monitoring strategy should account for regional variations:

Country	Currency	Key Competitors	Monitoring Focus
Singapore	SGD	GrabFood, Foodpanda	Premium pricing, promotions
Malaysia	MYR	GrabFood, Foodpanda	Value meals, free delivery
Thailand	THB	GrabFood, LINE MAN	Street food pricing, bundles
Indonesia	IDR	GoFood, GrabFood	Volume discounts, vouchers
Philippines	PHP	GrabFood, Foodpanda	Delivery fees, min orders
Vietnam	VND	GrabFood, Baemin	Flash sales, coins cashback

For each market, configure DataResearchTools mobile proxies with the appropriate country targeting to access market-specific data.

Scheduling and Automation

Monitoring Frequency Recommendations

Data Type	Recommended Frequency	Rationale
Menu prices	Every 6 hours	Prices change infrequently
Delivery fees	Every 30 minutes	Vary by demand
Vouchers and promotions	Every 2 hours	New campaigns launch throughout the day
Restaurant listings	Daily	New restaurants added regularly
Ratings and reviews	Weekly	Slow-changing metric

Cron-Based Scheduling

# Price monitoring - every 6 hours
0 */6 * * * python3 /opt/monitors/shopeefood_prices.py

# Delivery fee monitoring - every 30 minutes
*/30 * * * * python3 /opt/monitors/shopeefood_delivery_fees.py

# Voucher tracking - every 2 hours
0 */2 * * * python3 /opt/monitors/shopeefood_vouchers.py

# Daily restaurant discovery
0 3 * * * python3 /opt/monitors/shopeefood_restaurants.py

Handling Data Quality

Validation Rules

Ensure collected data is accurate and complete:

def validate_price_data(item):
    """Validate a scraped price data point."""
    errors = []

    if item.get("current_price") is None:
        errors.append("Missing price")
    elif item["current_price"] <= 0:
        errors.append("Invalid price: must be positive")
    elif item["current_price"] > 10000:
        errors.append("Suspicious price: unusually high")

    if not item.get("item_name"):
        errors.append("Missing item name")

    if item.get("discount_percentage") and (
        item["discount_percentage"] < 0 or item["discount_percentage"] > 100
    ):
        errors.append("Invalid discount percentage")

    return len(errors) == 0, errors

Anomaly Detection

Flag unusual pricing changes that may indicate data quality issues or genuine market events:

def detect_anomalies(price_history, threshold_std=2):
    """Detect anomalous price changes using statistical methods."""
    if len(price_history) < 5:
        return []

    prices = [p["current_price"] for p in price_history]
    mean_price = sum(prices) / len(prices)
    std_price = (sum((p - mean_price) ** 2 for p in prices) / len(prices)) ** 0.5

    anomalies = []
    for entry in price_history:
        if abs(entry["current_price"] - mean_price) > threshold_std * std_price:
            anomalies.append({
                "timestamp": entry["timestamp"],
                "price": entry["current_price"],
                "deviation": round((entry["current_price"] - mean_price) / std_price, 2)
            })

    return anomalies

Competitive Intelligence Applications

The data collected through ShopeeFood monitoring enables several strategic applications:

Price benchmarking: Compare your restaurant’s pricing against competitors on the platform
Promotion effectiveness: Track competitor promotion patterns and their impact on rankings
Market entry analysis: Understand pricing expectations before launching in a new city
Delivery optimization: Identify peak demand periods and adjust delivery capacity
Menu optimization: See which items competitors promote and at what price points

Conclusion

Monitoring ShopeeFood pricing and promotions requires a combination of reliable proxy infrastructure, systematic data collection, and intelligent analysis. Mobile proxies from DataResearchTools provide the foundation needed to collect accurate, location-specific data without triggering anti-bot defenses.

By establishing regular monitoring cycles and building analytical tools around the collected data, businesses can gain real-time visibility into the competitive landscape of Southeast Asia’s food delivery market. Start with your primary market, validate your data pipeline, and expand to additional countries as your monitoring needs grow.