Bunker Fuel Prices by Port: Singapore, Rotterdam, Fujairah & 7 More [Live Data]

Bunker fuel represents 50-60% of vessel operating costs. Finding the best bunkering port along your voyage route can save thousands per stop. This guide covers bunker fuel pricing fundamentals, port-by-port data, and how to access real-time prices via API for voyage cost calculators and bunkering optimization tools.

What Are Bunker Fuels?

Bunker fuel is the fuel used to power ships. The term comes from the coal bunkers on early steamships. Today, several grades of marine fuel are in common use:

Fuel Grade Overview

IMO 2020 Impact

Since January 2020, the IMO global sulfur cap limits fuel sulfur content to 0.5% outside Emission Control Areas. This made VLSFO the default fuel for most vessels, driving demand and price premiums over traditional HFO.

Major Bunkering Ports

Port Coverage

OilPriceAPI provides bunker fuel prices for the world's major bunkering hubs:

Port Profiles

Singapore (SGSIN)

• Status: World's largest bunkering port
• Strengths: Best liquidity, competitive pricing, 24/7 operations
• Typical premium/discount: Benchmark port
• Transit routes: Asia-Europe, Trans-Pacific

Rotterdam (NLRTM)

• Status: Europe's primary bunkering hub
• Strengths: ARA region integration, refinery connections
• Typical premium/discount: ~$5-15 premium to Singapore
• Transit routes: Transatlantic, Northern Europe

Fujairah (AEFUJ)

• Status: Middle East's largest bunker port
• Strengths: Strategic location, growing storage capacity
• Typical premium/discount: Varies with Middle East supply
• Transit routes: Asia-Europe via Suez, Middle East Gulf

Accessing Bunker Prices via API

Get All Marine Fuel Prices

Retrieve current prices across all ports and grades:

curl "https://api.oilpriceapi.com/v1/prices/marine-fuels/latest" \
  -H "Authorization: Token YOUR_API_KEY"

Response:

{
  "status": "success",
  "data": {
    "prices": [
      {
        "price": 585.0,
        "code": "VLSFO_SGSIN_USD",
        "port": "Singapore",
        "port_code": "SGSIN",
        "fuel_grade": "VLSFO",
        "currency": "USD",
        "created_at": "2026-01-30T12:00:00.000Z"
      },
      {
        "price": 598.5,
        "code": "VLSFO_NLRTM_USD",
        "port": "Rotterdam",
        "port_code": "NLRTM",
        "fuel_grade": "VLSFO",
        "currency": "USD",
        "created_at": "2026-01-30T12:00:00.000Z"
      }
    ]
  }
}

Get Port-Specific Pricing

Query specific ports for bunkering decisions:

# Singapore VLSFO
curl "https://api.oilpriceapi.com/v1/prices/latest?by_code=VLSFO_SGSIN_USD" \
  -H "Authorization: Token YOUR_API_KEY"

# Compare multiple ports
curl "https://api.oilpriceapi.com/v1/prices/latest?by_code=VLSFO_SGSIN_USD,VLSFO_NLRTM_USD,VLSFO_AEFUJ_USD" \
  -H "Authorization: Token YOUR_API_KEY"

Get Historical Bunker Prices

Analyze price trends for optimal bunkering timing:

# 30 days of Singapore VLSFO
curl "https://api.oilpriceapi.com/v1/prices/past_month?by_code=VLSFO_SGSIN_USD&interval=1d" \
  -H "Authorization: Token YOUR_API_KEY"

List Available Ports

Get information about supported bunkering ports:

curl "https://api.oilpriceapi.com/v1/prices/marine-fuels/ports" \
  -H "Authorization: Token YOUR_API_KEY"

Commodity Code Reference

VLSFO (Very Low Sulfur Fuel Oil)

MGO (Marine Gas Oil)

HFO (Heavy Fuel Oil)

Integration Examples

Python: Voyage Bunkering Optimizer

import requests
from dataclasses import dataclass
from typing import List, Optional

@dataclass
class Port:
    code: str
    name: str
    eta_days: int

class BunkeringOptimizer:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.oilpriceapi.com/v1"
        self.headers = {"Authorization": f"Token {api_key}"}

    def get_bunker_prices(self, port_codes: List[str], fuel_grade: str = "VLSFO") -> dict:
        """Get current bunker prices for specified ports."""
        codes = [f"{fuel_grade}_{code}_USD" for code in port_codes]
        response = requests.get(
            f"{self.base_url}/prices/latest",
            params={"by_code": ",".join(codes)},
            headers=self.headers
        )
        return response.json()

    def compare_ports(self, voyage_ports: List[Port], fuel_needed_mt: float,
                     fuel_grade: str = "VLSFO") -> List[dict]:
        """Compare bunkering costs across voyage ports."""
        port_codes = [p.code for p in voyage_ports]
        prices = self.get_bunker_prices(port_codes, fuel_grade)

        options = []
        for port in voyage_ports:
            code = f"{fuel_grade}_{port.code}_USD"
            price = self._extract_price(prices, code)

            if price:
                total_cost = price * fuel_needed_mt
                options.append({
                    "port": port.name,
                    "port_code": port.code,
                    "eta_days": port.eta_days,
                    "price_per_mt": price,
                    "total_cost": round(total_cost, 2),
                    "fuel_grade": fuel_grade,
                    "fuel_quantity_mt": fuel_needed_mt
                })

        return sorted(options, key=lambda x: x["total_cost"])

    def _extract_price(self, response: dict, code: str) -> Optional[float]:
        """Extract price from API response."""
        if response.get("status") == "success":
            data = response.get("data", {})
            # Handle single price response
            if isinstance(data, dict) and data.get("code") == code:
                return data.get("price")
            # Handle multiple prices response
            if isinstance(data, dict) and "prices" in data:
                for p in data["prices"]:
                    if p.get("code") == code:
                        return p.get("price")
        return None

    def calculate_savings(self, options: List[dict]) -> dict:
        """Calculate potential savings from optimal port selection."""
        if len(options) < 2:
            return {"savings": 0}

        cheapest = options[0]
        most_expensive = options[-1]

        return {
            "cheapest_port": cheapest["port"],
            "cheapest_cost": cheapest["total_cost"],
            "most_expensive_port": most_expensive["port"],
            "most_expensive_cost": most_expensive["total_cost"],
            "potential_savings": round(most_expensive["total_cost"] - cheapest["total_cost"], 2),
            "savings_percent": round((most_expensive["total_cost"] - cheapest["total_cost"]) / most_expensive["total_cost"] * 100, 1)
        }

# Usage example
optimizer = BunkeringOptimizer("YOUR_API_KEY")

# Define voyage ports
voyage = [
    Port(code="SGSIN", name="Singapore", eta_days=0),
    Port(code="AEFUJ", name="Fujairah", eta_days=6),
    Port(code="NLRTM", name="Rotterdam", eta_days=18)
]

# Compare bunkering options for 2,500 MT VLSFO
options = optimizer.compare_ports(voyage, fuel_needed_mt=2500)

print("Bunkering Options (sorted by cost):")
for opt in options:
    print(f"  {opt['port']}: ${opt['total_cost']:,.0f} (${opt['price_per_mt']:.2f}/MT)")

savings = optimizer.calculate_savings(options)
print(f"\nPotential Savings: ${savings['potential_savings']:,.0f} ({savings['savings_percent']}%)")

JavaScript: Fleet Bunker Dashboard

class BunkerDashboard {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = "https://api.oilpriceapi.com/v1";
  }

  async getAllBunkerPrices() {
    const response = await fetch(`${this.baseUrl}/prices/marine-fuels/latest`, {
      headers: { Authorization: `Token ${this.apiKey}` },
    });
    return response.json();
  }

  async getPortPrices(portCode) {
    const codes = [
      `VLSFO_${portCode}_USD`,
      `MGO_05S_${portCode}_USD`,
      `HFO_380_${portCode}_USD`,
    ].join(",");

    const response = await fetch(
      `${this.baseUrl}/prices/latest?by_code=${codes}`,
      { headers: { Authorization: `Token ${this.apiKey}` } },
    );
    return response.json();
  }

  async findCheapestPort(portCodes, fuelGrade = "VLSFO") {
    const codes = portCodes.map((p) => `${fuelGrade}_${p}_USD`).join(",");
    const response = await fetch(
      `${this.baseUrl}/prices/latest?by_code=${codes}`,
      { headers: { Authorization: `Token ${this.apiKey}` } },
    );
    const data = await response.json();

    // Parse and sort by price
    const prices = data.data.prices || [data.data];
    return prices.sort((a, b) => a.price - b.price);
  }

  async getHistoricalSpread(port1, port2, fuelGrade = "VLSFO", days = 30) {
    const codes = [`${fuelGrade}_${port1}_USD`, `${fuelGrade}_${port2}_USD`];
    const endpoint = days <= 7 ? "past_week" : "past_month";

    const responses = await Promise.all(
      codes.map((code) =>
        fetch(
          `${this.baseUrl}/prices/${endpoint}?by_code=${code}&interval=1d`,
          {
            headers: { Authorization: `Token ${this.apiKey}` },
          },
        ).then((r) => r.json()),
      ),
    );

    // Calculate spread over time
    const port1Prices = responses[0].data.prices;
    const port2Prices = responses[1].data.prices;

    return port1Prices.map((p1, i) => ({
      date: p1.created_at,
      [port1]: p1.price,
      [port2]: port2Prices[i]?.price,
      spread: p1.price - (port2Prices[i]?.price || 0),
    }));
  }
}

// Usage
const dashboard = new BunkerDashboard(process.env.OILPRICE_API_KEY);

// Find cheapest VLSFO across major ports
const ports = ["SGSIN", "NLRTM", "AEFUJ", "USHOU"];
const ranked = await dashboard.findCheapestPort(ports);

console.log("VLSFO Prices by Port:");
ranked.forEach((p) => {
  console.log(`  ${p.port}: $${p.price.toFixed(2)}/MT`);
});

// Calculate Singapore-Rotterdam spread over 30 days
const spread = await dashboard.getHistoricalSpread("SGSIN", "NLRTM");
const avgSpread = spread.reduce((sum, s) => sum + s.spread, 0) / spread.length;
console.log(
  `\nSingapore-Rotterdam 30d avg spread: $${avgSpread.toFixed(2)}/MT`,
);

Use Cases

1. Voyage Cost Calculation

Shipping companies integrate bunker prices into voyage P&L calculations:

• Estimate fuel costs for voyage planning
• Compare charter rates net of bunker costs
• Calculate spot vs. time charter economics

2. Bunkering Timing Optimization

Use historical price trends to identify optimal buying windows:

• Track price volatility by port
• Set price targets for advance purchases
• Alert on unusual price movements

3. Multi-Port Arbitrage

Identify price differentials between ports for arbitrage opportunities:

• Singapore vs. Rotterdam VLSFO spread
• Regional price discrepancies
• Seasonal patterns by geography

4. Voyage Planning Software

Software vendors embed bunker prices in planning tools:

• Display prices alongside voyage routes
• Calculate total voyage costs automatically
• Compare alternative routing options

5. Fleet Fuel Budgeting

Ship operators budget fuel costs across their fleet:

• Aggregate bunker costs by vessel
• Forecast quarterly fuel expenses
• Track budget vs. actual spending

ROI for Shipping Companies

Example ROI: For a vessel consuming 3,000 MT VLSFO per voyage at $600/MT:

• 3% optimization = $54,000 savings per voyage
• At 12 voyages/year = $648,000 annual savings

Getting Started

1. Sign up at oilpriceapi.com/signup - free tier available
2. Get your API key from the dashboard
3. Test marine fuel endpoints with the examples above
4. Build your integration into voyage planning or fleet management systems

The free tier includes 1,000 API requests monthly—enough to build and test your bunker price integration.

Frequently Asked Questions

How often are bunker prices updated?

OilPriceAPI updates marine fuel prices every 15 minutes during market hours. Major ports like Singapore, Rotterdam, and Fujairah have continuous price updates throughout the trading day.

Which fuel grades are included?

We cover VLSFO (IMO 2020 compliant), MGO 0.5%S, and HFO 380/180 across all supported ports. VLSFO has the most comprehensive coverage as it's now the default fuel for most vessels.

Can I get prices in currencies other than USD?

Bunker prices are standardized in USD, which is the industry convention for marine fuels. You can apply current exchange rates in your application for local currency display.

How does this compare to getting quotes from bunker brokers?

OilPriceAPI provides indicative market prices—useful for planning and budgeting. Actual bunkering quotes from brokers may vary based on delivery terms, payment terms, and volume. Our prices serve as a reliable benchmark for evaluating broker quotes.

Can I set up alerts for specific port prices?

Yes, use our webhook feature to receive notifications when prices cross specified thresholds. This is useful for triggering procurement decisions when prices reach target levels.

Related Resources

• Maritime Shipping Solution - Complete shipping integration guide
• Marine Fuels API Reference - Full API documentation
• Port Data - Supported port information
• Logistics Fuel API - Supply chain integration
• Fleet Management - Fleet fuel tracking