Monitoring Fuel Prices Across SEA for Logistics Cost Planning

Fuel costs represent 25-40% of total trucking expenses and a significant component of shipping and air cargo rates across Southeast Asia. With fuel prices varying significantly between countries, fluctuating based on government subsidies, and subject to rapid changes due to global oil markets, systematic fuel price monitoring is essential for logistics cost planning and management.

In Southeast Asia, fuel pricing is uniquely complex. Several countries maintain fuel subsidies that create artificial price levels, while others have fully liberalized fuel markets. The interplay between global crude oil prices, local refining capacity, currency movements, and government policy creates a dynamic pricing environment that demands continuous monitoring.

The Fuel Price Landscape in Southeast Asia

Country-Specific Fuel Pricing Mechanisms

Indonesia: Fuel pricing is partially regulated. Pertamina, the state oil company, sells subsidized fuel (Pertalite and diesel) at government-mandated prices, while premium fuels (Pertamax, Pertamax Turbo) are priced commercially. Subsidized fuel prices can remain stable for months before sudden adjustments.

Thailand: Fuel prices are market-driven but influenced by government stabilization funds. The Oil Fuel Fund (EFPO) absorbs some price volatility, creating a buffer between global oil price swings and pump prices. Prices are updated daily at most stations.

Vietnam: Fuel prices are regulated by the government and adjusted approximately every 10 days based on a prescribed formula. The Ministry of Industry and Trade and the Ministry of Finance jointly manage pricing through the Petroleum Price Stabilization Fund.

Philippines: Fully deregulated fuel market since 1998. Oil companies set their own prices, typically adjusting weekly based on international benchmarks. This creates the most dynamic fuel pricing environment in the region.

Malaysia: Partially subsidized. The government sets weekly ceiling prices for RON95 petrol and diesel through the Automatic Pricing Mechanism (APM). RON97 is market-priced.

Singapore: Fully market-driven with competitive pricing among stations. Prices change frequently but are among the highest in the region due to lack of domestic production and high taxes.

Key Fuel Types for Logistics

Diesel (B20/B30/B35 biodiesel blends): Primary fuel for trucks and heavy vehicles. Indonesia mandates B35 (35% palm oil biodiesel blend).
RON 92/95 Petrol: Used by smaller delivery vehicles, motorcycles, and cars
Jet fuel (Jet A-1): Critical for air cargo cost calculations
Marine fuel oil (VLSFO/MGO): Relevant for shipping cost analysis

Data Sources for Fuel Price Monitoring

Government and Regulatory Sources

Each country publishes official fuel price data through government agencies:

Indonesia: Ministry of Energy (ESDM) announcements and Pertamina’s website
Thailand: EPPO (Energy Policy and Planning Office) daily fuel price reports
Vietnam: Ministry of Industry and Trade price adjustment announcements
Philippines: Department of Energy (DOE) weekly price monitoring reports
Malaysia: Ministry of Finance weekly fuel price announcements
Singapore: Singapore Department of Statistics

Oil Company Platforms

Major oil companies publish retail prices:

Pertamina (Indonesia): Station-level pricing through their app and website
PTT (Thailand): Real-time pump prices at PTT stations
Petron, Shell, Caltex: Regional presence with country-specific pricing pages
PetroVietnam: Vietnam’s national oil company pricing

Market and Benchmark Sources

Platts/S&P Global: Singapore benchmark prices (MOPS – Mean of Platts Singapore)
ICE Futures: Brent crude and gasoil futures
Bloomberg commodity data: Comprehensive energy pricing
OPEC reports: Production and supply data affecting global prices

Why Proxies Are Essential for Fuel Price Monitoring

Localized Data Access

Fuel price data is inherently local:

Government portals: Energy ministry websites are designed for domestic audiences. Accessing Indonesia’s ESDM portal from a Singaporean IP may return different content or experience access restrictions.

Oil company apps and websites: Pertamina’s price lookup, PTT’s price board, and similar tools serve locally relevant data based on the user’s location. A proxy from the correct country ensures accurate local pricing.

Station-level pricing: Some platforms show station-specific prices that vary by location. Mobile proxies from DataResearchTools enable querying prices at specific geographic locations within each country.

Consistent Data Collection

Fuel prices change frequently in deregulated markets. Missing a data collection window can create gaps that undermine trend analysis. Mobile proxies from DataResearchTools provide the reliability needed for consistent daily or more frequent price collection.

Multi-Country Coordination

Monitoring fuel prices across six SEA countries requires proxies in each country to access local data sources. DataResearchTools provides this multi-country coverage through a single proxy provider.

Building a Fuel Price Monitoring System

Data Model

from dataclasses import dataclass
from typing import Optional

@dataclass
class FuelPriceRecord:
    country: str
    city: Optional[str]
    fuel_type: str  # diesel, ron92, ron95, ron97, jet_a1, vlsfo
    brand: str  # pertamina, ptt, shell, petron, etc.
    price_per_liter: float
    currency: str
    price_usd_per_liter: Optional[float]
    is_subsidized: bool
    effective_date: str
    source: str
    collected_at: str

Collection Implementation

class FuelPriceCollector:
    """Collect fuel prices across SEA countries."""

    def __init__(self, proxy_config):
        self.proxy_config = proxy_config
        self.country_collectors = {
            "id": IndonesiaFuelCollector(proxy_config),
            "th": ThailandFuelCollector(proxy_config),
            "vn": VietnamFuelCollector(proxy_config),
            "ph": PhilippinesFuelCollector(proxy_config),
            "my": MalaysiaFuelCollector(proxy_config),
            "sg": SingaporeFuelCollector(proxy_config),
        }

    def collect_all_prices(self):
        """Collect current fuel prices from all countries."""
        all_prices = []

        for country, collector in self.country_collectors.items():
            try:
                prices = collector.collect()
                all_prices.extend(prices)
                print(f"Collected {len(prices)} prices from {country.upper()}")
            except Exception as e:
                print(f"Error collecting from {country}: {e}")

            time.sleep(random.uniform(3, 6))

        return all_prices


class ThailandFuelCollector:
    """Collect fuel prices from Thailand sources."""

    def __init__(self, proxy_config):
        self.proxy = proxy_config.get_proxy("th")

    def collect(self):
        """Collect current Thai fuel prices."""
        session = requests.Session()
        session.proxies = self.proxy
        session.headers.update({
            "User-Agent": (
                "Mozilla/5.0 (Linux; Android 14; OPPO A78) "
                "AppleWebKit/537.36 Chrome/121.0.0.0 Mobile Safari/537.36"
            ),
            "Accept-Language": "th-TH,th;q=0.9,en;q=0.8",
        })

        prices = []

        # Collect from EPPO (Energy Policy and Planning Office)
        try:
            response = session.get(
                "https://www.eppo.go.th/api/fuel-prices",
                timeout=30,
            )
            if response.status_code == 200:
                data = response.json()
                for fuel in data.get("prices", []):
                    prices.append(FuelPriceRecord(
                        country="TH",
                        city=None,
                        fuel_type=self._map_fuel_type(fuel["type"]),
                        brand="market_average",
                        price_per_liter=fuel["price"],
                        currency="THB",
                        price_usd_per_liter=fuel["price"] * 0.028,
                        is_subsidized="diesel" in fuel["type"].lower(),
                        effective_date=fuel.get("date", ""),
                        source="EPPO",
                        collected_at=datetime.utcnow().isoformat(),
                    ))
        except Exception as e:
            print(f"EPPO collection error: {e}")

        # Collect from PTT stations
        try:
            response = session.get(
                "https://www.pttplc.com/api/oil-prices",
                timeout=30,
            )
            if response.status_code == 200:
                data = response.json()
                for fuel in data.get("retail_prices", []):
                    prices.append(FuelPriceRecord(
                        country="TH",
                        city=None,
                        fuel_type=self._map_fuel_type(fuel["product"]),
                        brand="PTT",
                        price_per_liter=fuel["price_thb"],
                        currency="THB",
                        price_usd_per_liter=fuel["price_thb"] * 0.028,
                        is_subsidized=False,
                        effective_date=fuel.get("effective_date", ""),
                        source="PTT",
                        collected_at=datetime.utcnow().isoformat(),
                    ))
        except Exception as e:
            print(f"PTT collection error: {e}")

        return prices

    def _map_fuel_type(self, raw_type):
        mapping = {
            "ดีเซล": "diesel",
            "diesel b7": "diesel",
            "diesel b20": "diesel_b20",
            "เบนซิน 91": "ron91",
            "แก๊สโซฮอล์ 91": "ron91_e10",
            "แก๊สโซฮอล์ 95": "ron95_e10",
            "เบนซิน 95": "ron95",
        }
        return mapping.get(raw_type.lower(), raw_type.lower())


class IndonesiaFuelCollector:
    """Collect fuel prices from Indonesia sources."""

    def __init__(self, proxy_config):
        self.proxy = proxy_config.get_proxy("id")

    def collect(self):
        """Collect current Indonesian fuel prices."""
        session = requests.Session()
        session.proxies = self.proxy
        session.headers.update({
            "User-Agent": (
                "Mozilla/5.0 (Linux; Android 13; Samsung SM-A546B) "
                "AppleWebKit/537.36 Chrome/120.0.0.0 Mobile Safari/537.36"
            ),
            "Accept-Language": "id-ID,id;q=0.9,en;q=0.8",
        })

        prices = []

        # Pertamina subsidized and non-subsidized prices
        try:
            response = session.get(
                "https://www.pertamina.com/api/fuel-prices",
                timeout=30,
            )
            if response.status_code == 200:
                data = response.json()
                for product in data.get("products", []):
                    prices.append(FuelPriceRecord(
                        country="ID",
                        city=None,
                        fuel_type=self._map_fuel_type(product["name"]),
                        brand="Pertamina",
                        price_per_liter=product["price_idr"],
                        currency="IDR",
                        price_usd_per_liter=product["price_idr"] * 0.000063,
                        is_subsidized=product.get("subsidized", False),
                        effective_date=product.get("effective_date", ""),
                        source="Pertamina",
                        collected_at=datetime.utcnow().isoformat(),
                    ))
        except Exception as e:
            print(f"Pertamina collection error: {e}")

        return prices

    def _map_fuel_type(self, name):
        mapping = {
            "pertalite": "ron90_subsidized",
            "pertamax": "ron92",
            "pertamax turbo": "ron98",
            "solar": "diesel_subsidized",
            "dexlite": "diesel_cn51",
            "pertamina dex": "diesel_cn53",
        }
        return mapping.get(name.lower(), name.lower())

Cross-Country Price Comparison

class FuelPriceAnalyzer:
    """Analyze fuel prices across SEA countries."""

    EXCHANGE_RATES = {
        "THB": 0.028, "IDR": 0.000063, "VND": 0.000040,
        "PHP": 0.018, "MYR": 0.22, "SGD": 0.74, "USD": 1.0,
    }

    def compare_prices(self, prices, fuel_type="diesel"):
        """Compare fuel prices across countries for a specific fuel type."""
        filtered = [
            p for p in prices
            if fuel_type in p.fuel_type and not p.is_subsidized
        ]

        comparison = {}
        for price in filtered:
            country = price.country
            usd_price = price.price_per_liter * self.EXCHANGE_RATES.get(
                price.currency, 1
            )
            if country not in comparison or usd_price < comparison[country]["price_usd"]:
                comparison[country] = {
                    "country": country,
                    "price_local": price.price_per_liter,
                    "currency": price.currency,
                    "price_usd": round(usd_price, 4),
                    "source": price.source,
                    "effective_date": price.effective_date,
                }

        # Sort by USD price
        sorted_comparison = sorted(
            comparison.values(), key=lambda x: x["price_usd"]
        )

        if sorted_comparison:
            cheapest = sorted_comparison[0]["price_usd"]
            for entry in sorted_comparison:
                entry["vs_cheapest_pct"] = round(
                    (entry["price_usd"] / cheapest - 1) * 100, 1
                )

        return sorted_comparison

    def calculate_logistics_impact(
        self, fuel_prices, route_distances, fuel_consumption
    ):
        """Calculate fuel cost impact on logistics routes."""
        impacts = []

        for route in route_distances:
            country = route["country"]
            distance_km = route["distance_km"]

            # Find diesel price for this country
            diesel_price = next(
                (p for p in fuel_prices
                 if p.country == country and "diesel" in p.fuel_type
                 and not p.is_subsidized),
                None
            )

            if diesel_price:
                fuel_needed = distance_km * fuel_consumption  # liters per km
                fuel_cost_local = fuel_needed * diesel_price.price_per_liter
                fuel_cost_usd = fuel_cost_local * self.EXCHANGE_RATES.get(
                    diesel_price.currency, 1
                )

                impacts.append({
                    "route": f"{route['origin']} -> {route['destination']}",
                    "country": country,
                    "distance_km": distance_km,
                    "fuel_needed_liters": round(fuel_needed, 1),
                    "fuel_cost_local": round(fuel_cost_local, 2),
                    "fuel_cost_usd": round(fuel_cost_usd, 2),
                    "cost_per_km_usd": round(
                        fuel_cost_usd / distance_km, 4
                    ),
                    "currency": diesel_price.currency,
                })

        return impacts

    def track_price_trends(self, historical_prices, fuel_type="diesel"):
        """Track fuel price trends over time."""
        df = pd.DataFrame([
            {
                "date": p.effective_date,
                "country": p.country,
                "price_usd": p.price_per_liter * self.EXCHANGE_RATES.get(
                    p.currency, 1
                ),
            }
            for p in historical_prices
            if fuel_type in p.fuel_type and not p.is_subsidized
        ])

        df["date"] = pd.to_datetime(df["date"])

        trends = df.groupby(["country", pd.Grouper(key="date", freq="W")]).agg({
            "price_usd": "mean",
        }).reset_index()

        # Calculate week-over-week changes
        for country in trends["country"].unique():
            mask = trends["country"] == country
            trends.loc[mask, "wow_change_pct"] = (
                trends.loc[mask, "price_usd"].pct_change() * 100
            ).round(2)

        return trends

Fuel Surcharge Prediction

class FuelSurchargePredictor:
    """Predict logistics fuel surcharges based on fuel price data."""

    def predict_carrier_surcharge(
        self, current_fuel_price, carrier_base_fuel_price, carrier_surcharge_formula
    ):
        """
        Predict fuel surcharge based on carrier's formula.
        Most carriers use a step function based on fuel price ranges.
        """
        price_delta = current_fuel_price - carrier_base_fuel_price

        # Example: carrier applies surcharge per bracket
        brackets = carrier_surcharge_formula.get("brackets", [])
        surcharge = 0

        for bracket in brackets:
            if price_delta >= bracket["min_delta"]:
                surcharge = bracket["surcharge_pct"]

        return {
            "current_fuel_price": current_fuel_price,
            "base_fuel_price": carrier_base_fuel_price,
            "price_delta": round(price_delta, 4),
            "predicted_surcharge_pct": surcharge,
        }

    def estimate_total_fuel_impact(
        self, shipment_value, fuel_surcharge_pct, fuel_cost_component_pct
    ):
        """Estimate total fuel cost impact on a shipment."""
        base_fuel_cost = shipment_value * (fuel_cost_component_pct / 100)
        surcharge_amount = base_fuel_cost * (fuel_surcharge_pct / 100)

        return {
            "shipment_value": shipment_value,
            "base_fuel_component": round(base_fuel_cost, 2),
            "fuel_surcharge": round(surcharge_amount, 2),
            "total_fuel_cost": round(base_fuel_cost + surcharge_amount, 2),
            "fuel_as_pct_of_shipment": round(
                (base_fuel_cost + surcharge_amount) / shipment_value * 100, 1
            ),
        }

DataResearchTools for Fuel Price Monitoring

DataResearchTools mobile proxies provide specific advantages for fuel price monitoring:

Government portal access: Reliably access energy ministry websites and regulatory portals in each SEA country
Oil company data: Access Pertamina, PTT, Petron, and other oil company pricing pages with local mobile IPs
Station-level data: Some platforms show location-specific pricing that requires local IP access
Daily collection: Reliable mobile connections enable the daily or more frequent collection cadence needed for fuel price tracking

Conclusion

Fuel price monitoring across Southeast Asia is a foundational capability for logistics cost planning. The region’s diverse pricing mechanisms, subsidy structures, and market dynamics create significant price differences between countries and over time. Companies that systematically monitor these prices can more accurately forecast logistics costs, negotiate fuel surcharges, and optimize routing decisions.

DataResearchTools mobile proxies enable reliable access to fuel price data from government agencies, oil companies, and market platforms across all major SEA markets. By building a structured monitoring system with cross-country comparison and trend analysis, logistics companies can turn fuel price intelligence into a meaningful cost management advantage.