Get All Marine Fuels

Get comprehensive marine fuel prices from all ports and all fuel grades.

GET/v1/prices/marine-fuels

Request

Headers

Header	Required	Description
`Authorization`	Yes	Token authentication with your API key
`Accept`	No	`application/json` (default)

Query Parameters

Parameter	Type	Required	Description	Example
`port`	string	No	Filter by specific port code	`SGSIN`, `NLRTM`
`fuel_type`	string	No	Filter by fuel grade	`VLSFO`, `MGO_05`, `HFO_380`
`region`	string	No	Filter by region	`asia`, `europe`, `americas`

Response

Success Response (200 OK)

All Marine Fuels

{
  "status": "success",
  "data": {
    "marine_fuels": [
      {
        "port": {
          "code": "SGSIN",
          "name": "Singapore",
          "country": "Singapore",
          "region": "asia",
          "coordinates": {
            "latitude": 1.2966,
            "longitude": 103.7764
          }
        },
        "prices": {
          "MGO_05": {
            "fuel_type": "MGO_05",
            "fuel_name": "Marine Gas Oil 0.5%S",
            "price": 645.5,
            "formatted": "$645.50",
            "currency": "USD",
            "unit": "metric_ton",
            "timestamp": "2025-08-05T00:15:00Z",
            "change_24h": 2.5,
            "change_percent": 0.39
          },
          "VLSFO": {
            "fuel_type": "VLSFO",
            "fuel_name": "Very Low Sulfur Fuel Oil",
            "price": 517.5,
            "formatted": "$517.50",
            "currency": "USD",
            "unit": "metric_ton",
            "timestamp": "2025-08-05T00:15:00Z",
            "change_24h": -1.25,
            "change_percent": -0.24
          },
          "HFO_380": {
            "fuel_type": "HFO_380",
            "fuel_name": "Heavy Fuel Oil 380 CST",
            "price": 398.0,
            "formatted": "$398.00",
            "currency": "USD",
            "unit": "metric_ton",
            "timestamp": "2025-08-05T00:15:00Z",
            "change_24h": 1.75,
            "change_percent": 0.44
          }
        }
      },
      {
        "port": {
          "code": "NLRTM",
          "name": "Rotterdam",
          "country": "Netherlands",
          "region": "europe",
          "coordinates": {
            "latitude": 51.9225,
            "longitude": 4.47917
          }
        },
        "prices": {
          "MGO_05": {
            "fuel_type": "MGO_05",
            "fuel_name": "Marine Gas Oil 0.5%S",
            "price": 634.25,
            "formatted": "$634.25",
            "currency": "USD",
            "unit": "metric_ton",
            "timestamp": "2025-08-05T00:15:00Z",
            "change_24h": 1.5,
            "change_percent": 0.24
          },
          "VLSFO": {
            "fuel_type": "VLSFO",
            "fuel_name": "Very Low Sulfur Fuel Oil",
            "price": 510.75,
            "formatted": "$510.75",
            "currency": "USD",
            "unit": "metric_ton",
            "timestamp": "2025-08-05T00:15:00Z",
            "change_24h": -2.0,
            "change_percent": -0.39
          }
        }
      }
    ]
  },
  "meta": {
    "total_ports": 8,
    "fuel_grades": 4,
    "last_updated": "2025-08-05T00:15:00Z",
    "update_frequency": "15 minutes",
    "request_id": "req_marine123"
  }
}

Filtered by Port

// GET /v1/prices/marine-fuels?port=SGSIN

{
  "status": "success",
  "data": {
    "marine_fuels": [
      {
        "port": {
          "code": "SGSIN",
          "name": "Singapore",
          "country": "Singapore",
          "region": "asia"
        },
        "prices": {
          "MGO_05": {
            "price": 645.5,
            "formatted": "$645.50"
          },
          "VLSFO": {
            "price": 517.5,
            "formatted": "$517.50"
          }
        }
      }
    ]
  }
}

Filtered by Fuel Type

// GET /v1/prices/marine-fuels?fuel_type=VLSFO

{
  "status": "success",
  "data": {
    "marine_fuels": [
      {
        "port": {
          "code": "SGSIN",
          "name": "Singapore"
        },
        "prices": {
          "VLSFO": {
            "price": 517.5,
            "formatted": "$517.50",
            "change_24h": -1.25
          }
        }
      },
      {
        "port": {
          "code": "NLRTM",
          "name": "Rotterdam"
        },
        "prices": {
          "VLSFO": {
            "price": 510.75,
            "formatted": "$510.75",
            "change_24h": -2.0
          }
        }
      }
    ]
  }
}

Code Examples

cURL

# Get all marine fuel prices
curl https://api.oilpriceapi.com/v1/prices/marine-fuels \
  -H "Authorization: Token YOUR_API_KEY"

# Get Singapore prices only
curl https://api.oilpriceapi.com/v1/prices/marine-fuels?port=SGSIN \
  -H "Authorization: Token YOUR_API_KEY"

# Get VLSFO prices across all ports
curl https://api.oilpriceapi.com/v1/prices/marine-fuels?fuel_type=VLSFO \
  -H "Authorization: Token YOUR_API_KEY"

# Get European ports only
curl https://api.oilpriceapi.com/v1/prices/marine-fuels?region=europe \
  -H "Authorization: Token YOUR_API_KEY"

JavaScript

async function getMarineFuelPrices(filters = {}) {
  const params = new URLSearchParams(filters);

  const response = await fetch(
    `https://api.oilpriceapi.com/v1/prices/marine-fuels?${params}`,
    {
      headers: {
        Authorization: "Token YOUR_API_KEY",
      },
    },
  );

  const data = await response.json();
  return data.data.marine_fuels;
}

// Get all marine fuel prices
const allPrices = await getMarineFuelPrices();

// Find cheapest VLSFO price
const vlsfoPrice = await getMarineFuelPrices({ fuel_type: "VLSFO" });
const cheapest = vlsfoPrice
  .map((port) => ({
    port: port.port.name,
    price: port.prices.VLSFO.price,
  }))
  .sort((a, b) => a.price - b.price)[0];

console.log(`Cheapest VLSFO: ${cheapest.port} at $${cheapest.price}/MT`);

// Compare Asia vs Europe VLSFO prices
const asiaPrices = await getMarineFuelPrices({
  fuel_type: "VLSFO",
  region: "asia",
});
const europePrices = await getMarineFuelPrices({
  fuel_type: "VLSFO",
  region: "europe",
});

const asiaAvg =
  asiaPrices.reduce((sum, p) => sum + p.prices.VLSFO.price, 0) /
  asiaPrices.length;
const europeAvg =
  europePrices.reduce((sum, p) => sum + p.prices.VLSFO.price, 0) /
  europePrices.length;

console.log(
  `Asia-Europe VLSFO spread: $${(asiaAvg - europeAvg).toFixed(2)}/MT`,
);

Python

import requests
from typing import List, Dict, Optional

class MarineFuelAPI:
    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_marine_fuels(self, port: str = None, fuel_type: str = None,
                        region: str = None) -> List[Dict]:
        """Get marine fuel prices with optional filtering"""
        params = {}
        if port:
            params['port'] = port
        if fuel_type:
            params['fuel_type'] = fuel_type
        if region:
            params['region'] = region

        response = requests.get(
            f'{self.base_url}/prices/marine-fuels',
            headers=self.headers,
            params=params
        )
        response.raise_for_status()

        return response.json()['data']['marine_fuels']

    def get_port_prices(self, port_code: str) -> Dict:
        """Get all fuel prices for a specific port"""
        marine_fuels = self.get_marine_fuels(port=port_code)
        return marine_fuels[0] if marine_fuels else None

    def find_best_price(self, fuel_type: str) -> Dict:
        """Find the port with the best price for a fuel type"""
        fuels = self.get_marine_fuels(fuel_type=fuel_type)

        best_port = min(fuels, key=lambda x: x['prices'][fuel_type]['price'])

        return {
            'port': best_port['port']['name'],
            'port_code': best_port['port']['code'],
            'price': best_port['prices'][fuel_type]['price'],
            'formatted': best_port['prices'][fuel_type]['formatted']
        }

    def calculate_regional_spread(self, fuel_type: str,
                                 region1: str, region2: str) -> Dict:
        """Calculate price spread between two regions"""
        r1_fuels = self.get_marine_fuels(fuel_type=fuel_type, region=region1)
        r2_fuels = self.get_marine_fuels(fuel_type=fuel_type, region=region2)

        r1_avg = sum(f['prices'][fuel_type]['price'] for f in r1_fuels) / len(r1_fuels)
        r2_avg = sum(f['prices'][fuel_type]['price'] for f in r2_fuels) / len(r2_fuels)

        return {
            f'{region1}_average': r1_avg,
            f'{region2}_average': r2_avg,
            'spread': r1_avg - r2_avg,
            'spread_percent': ((r1_avg - r2_avg) / r2_avg) * 100
        }

# Example usage
api = MarineFuelAPI('YOUR_API_KEY')

# Get all marine fuel prices
all_prices = api.get_marine_fuels()
print(f"Found prices for {len(all_prices)} ports")

# Find cheapest VLSFO
cheapest_vlsfo = api.find_best_price('VLSFO')
print(f"Cheapest VLSFO: {cheapest_vlsfo['port']} at {cheapest_vlsfo['formatted']}")

# Calculate Asia-Europe spread
spread = api.calculate_regional_spread('VLSFO', 'asia', 'europe')
print(f"Asia-Europe VLSFO spread: ${spread['spread']:.2f}/MT ({spread['spread_percent']:.1f}%)")

# Monitor Singapore prices
singapore = api.get_port_prices('SGSIN')
if singapore:
    print(f"Singapore VLSFO: {singapore['prices']['VLSFO']['formatted']}")
    print(f"24h change: {singapore['prices']['VLSFO']['change_24h']:+.2f}")

Port Codes

Code	Port	Country	Region
SGSIN	Singapore	Singapore	asia
NLRTM	Rotterdam	Netherlands	europe
USHOU	Houston	United States	americas
AEFUJ	Fujairah	UAE	middle_east
HKHKG	Hong Kong	Hong Kong	asia
USLAX	Los Angeles	United States	americas
USNYC	New York	United States	americas
BRSSZ	Santos	Brazil	americas

Fuel Types

Code	Full Name	Sulfur Content	IMO 2020 Compliant
MGO_05	Marine Gas Oil 0.5%S	≤ 0.5%	✅ Yes
VLSFO	Very Low Sulfur Fuel Oil	≤ 0.5%	✅ Yes
HFO_380	Heavy Fuel Oil 380 CST	~3.5%	❌ Scrubber required

Use Cases

1. Bunker Procurement Strategy

// Find optimal bunkering port for a voyage
async function findOptimalBunkering(voyageRoute, fuelRequired) {
  const fuelType = "VLSFO";
  const prices = await getMarineFuelPrices({ fuel_type: fuelType });

  // Filter ports along the route
  const routePorts = prices.filter((port) =>
    voyageRoute.includes(port.port.code),
  );

  // Calculate total cost including deviation
  const options = routePorts.map((port) => ({
    port: port.port.name,
    fuelCost: port.prices[fuelType].price * fuelRequired,
    deviationCost: calculateDeviationCost(voyageRoute, port.port.code),
    totalCost:
      port.prices[fuelType].price * fuelRequired +
      calculateDeviationCost(voyageRoute, port.port.code),
  }));

  return options.sort((a, b) => a.totalCost - b.totalCost)[0];
}

2. Price Alert System

# Monitor price changes and trigger alerts
def monitor_price_changes(threshold_percent=2.0):
    api = MarineFuelAPI('YOUR_API_KEY')

    current_prices = api.get_marine_fuels()

    for port_data in current_prices:
        for fuel_type, price_data in port_data['prices'].items():
            change_percent = abs(price_data['change_percent'])

            if change_percent >= threshold_percent:
                send_alert({
                    'port': port_data['port']['name'],
                    'fuel': fuel_type,
                    'price': price_data['formatted'],
                    'change': f"{price_data['change_percent']:+.1f}%",
                    'timestamp': price_data['timestamp']
                })

3. Market Analysis Dashboard

// Create real-time market analysis
async function createMarketDashboard() {
  const allPrices = await getMarineFuelPrices();

  // Calculate market statistics
  const stats = {
    totalPorts: allPrices.length,
    priceRanges: {},
    regionalAverages: {},
    volatility: {},
  };

  // Price ranges by fuel type
  ["MGO_05", "VLSFO", "HFO_380"].forEach((fuelType) => {
    const prices = allPrices
      .filter((p) => p.prices[fuelType])
      .map((p) => p.prices[fuelType].price);

    stats.priceRanges[fuelType] = {
      min: Math.min(...prices),
      max: Math.max(...prices),
      avg: prices.reduce((a, b) => a + b, 0) / prices.length,
      spread: Math.max(...prices) - Math.min(...prices),
    };
  });

  // Regional averages
  const regions = ["asia", "europe", "americas"];
  regions.forEach((region) => {
    const regionPorts = allPrices.filter((p) => p.port.region === region);
    stats.regionalAverages[region] = calculateRegionalStats(regionPorts);
  });

  return stats;
}

GET /v1/prices/marine-fuels/ports - Port information and capabilities. Per-port detail is available through /v1/marine-ports/:id, not /v1/prices/marine-fuels/ports/:code.
GET /v1/prices/latest - All commodity prices including marine fuels