Historical Oil Price Data API Guide: Best Sources for Backtesting

# OilPriceAPI
GET /v1/prices/historical
  ?by_code=WTI_USD
  &start_date=2024-01-01
  &end_date=2024-12-31
  &interval=daily

# EIA
GET /v2/petroleum/pri/spt/data/
  ?api_key=YOUR_KEY
  &frequency=daily
  &data[0]=value
  &facets[product][]=EPCBRENT
  &start=2024-01-01
  &end=2024-12-31

• commodity / by_code: Which oil benchmark (WTI_USD, BRENT_CRUDE_USD)
• start_date / end_date: Date range (ISO 8601 format: YYYY-MM-DD)
• interval / frequency: Data granularity (daily, hourly, 5-minute)
• limit / offset: Pagination for large datasets
• format: Response format (json, csv, xml)

# Request page 1
GET /v1/prices/historical?by_code=WTI_USD&start_date=2020-01-01&end_date=2024-12-31&limit=10000&offset=0

# Response includes pagination
{
  "data": [...10000 records...],
  "pagination": {
    "total": 105120,
    "limit": 10000,
    "offset": 0,
    "next": "/v1/prices/historical?...&offset=10000"
  }
}

# Request page 2
GET /v1/prices/historical?...&offset=10000

from oilpriceapi import Client
from datetime import datetime, timedelta
import pandas as pd

client = Client(api_key="your_api_key_here")

# Define date range
end_date = datetime.now()
start_date = end_date - timedelta(days=365 * 5)  # 5 years

print(f"Fetching WTI data from {start_date.date()} to {end_date.date()}...")

# Fetch historical data
historical_data = client.get_historical_prices(
    by_code="WTI_USD",
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d")
)

# Convert to DataFrame
df = pd.DataFrame(historical_data['data'])
df['created_at'] = pd.to_datetime(df['created_at'])
df = df.sort_values('created_at')

print(f"\nFetched {len(df)} data points")
print(f"Date range: {df['created_at'].min()} to {df['created_at'].max()}")
print(f"Price range: $"+f"{df['price'].min():.2f} to $"+f"{df['price'].max():.2f}")

# Save to CSV
df.to_csv('wti_5year_history.csv', index=False)
print("\nData saved to wti_5year_history.csv")

const { OilPriceAPIClient } = require('@oilpriceapi/client');
const fs = require('fs');

const client = new OilPriceAPIClient({
  apiKey: process.env.OILPRICEAPI_KEY
});

async function fetchHistoricalData(commodity, years) {
  const endDate = new Date();
  const startDate = new Date();
  startDate.setFullYear(startDate.getFullYear() - years);

  console.log(`Fetching \${years} years of \${commodity} data...`);

  const data = await client.getHistoricalPrices({
    code: commodity,
    startDate: startDate.toISOString().split('T')[0],
    endDate: endDate.toISOString().split('T')[0]
  });

  console.log(`Fetched \${data.data.length} records`);

  // Save to JSON file
  const filename = `\${commodity}_\${years}year_history.json`;
  fs.writeFileSync(filename, JSON.stringify(data, null, 2));
  console.log(`Saved to \${filename}`);

  return data;
}

// Fetch multiple commodities in parallel
async function fetchMultipleCommodities() {
  const commodities = ['WTI_USD', 'BRENT_CRUDE_USD', 'NATURAL_GAS_USD'];

  const promises = commodities.map(code =>
    fetchHistoricalData(code, 3)
  );

  await Promise.all(promises);
  console.log('\nAll data fetched successfully!');
}

fetchMultipleCommodities();

# Fetch 1 year of Brent data as CSV
curl -X GET "https://api.oilpriceapi.com/v1/prices/historical" \
  -H "Authorization: Token YOUR_API_KEY" \
  -G \
  --data-urlencode "by_code=BRENT_CRUDE_USD" \
  --data-urlencode "start_date=2024-01-01" \
  --data-urlencode "end_date=2024-12-31" \
  --data-urlencode "format=csv" \
  > brent_2024.csv

echo "Data saved to brent_2024.csv"

# Preview first 10 lines
head -n 10 brent_2024.csv

=OILPRICE.GET("/v1/prices/historical", "by_code=WTI_USD&start_date=2020-01-01&end_date=2024-12-31")

import pandas as pd
from oilpriceapi import Client
from datetime import datetime, timedelta

client = Client(api_key="your_api_key_here")

# Fetch 1 year of WTI data
end_date = datetime.now()
start_date = end_date - timedelta(days=365)

data = client.get_historical_prices(
    by_code="WTI_USD",
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d")
)

# Create DataFrame
df = pd.DataFrame(data['data'])
df['created_at'] = pd.to_datetime(df['created_at'])
df = df.set_index('created_at').sort_index()

# Calculate moving averages
df['MA_7'] = df['price'].rolling(window=7).mean()
df['MA_30'] = df['price'].rolling(window=30).mean()
df['MA_90'] = df['price'].rolling(window=90).mean()

# Current values
print("WTI Moving Averages")
print("=" * 50)
print(f"Current Price: \\$\{df['price'].iloc[-1]:.2f\}")
print(f"7-day MA:      \\$\{df['MA_7'].iloc[-1]:.2f\}")
print(f"30-day MA:     \\$\{df['MA_30'].iloc[-1]:.2f\}")
print(f"90-day MA:     \\$\{df['MA_90'].iloc[-1]:.2f\}")

# Trend identification
if df['MA_7'].iloc[-1] > df['MA_30'].iloc[-1] > df['MA_90'].iloc[-1]:
    print("\nTrend: STRONG UPTREND (all MAs ascending)")
elif df['MA_7'].iloc[-1] < df['MA_30'].iloc[-1] < df['MA_90'].iloc[-1]:
    print("\nTrend: STRONG DOWNTREND (all MAs descending)")
else:
    print("\nTrend: MIXED (choppy market)")

import pandas as pd
import numpy as np
from oilpriceapi import Client
from datetime import datetime, timedelta

client = Client(api_key="your_api_key_here")

# Fetch 2 years of data
end_date = datetime.now()
start_date = end_date - timedelta(days=730)

data = client.get_historical_prices(
    by_code="BRENT_CRUDE_USD",
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d")
)

df = pd.DataFrame(data['data'])
df['created_at'] = pd.to_datetime(df['created_at'])
df = df.set_index('created_at').sort_index()

# Calculate daily returns
df['returns'] = df['price'].pct_change()

# Rolling volatility (annualized)
df['volatility_30d'] = df['returns'].rolling(window=30).std() * np.sqrt(252)
df['volatility_90d'] = df['returns'].rolling(window=90).std() * np.sqrt(252)

print("Brent Crude Volatility Analysis")
print("=" * 50)
print(f"30-day volatility:  {df['volatility_30d'].iloc[-1]:.2%}")
print(f"90-day volatility:  {df['volatility_90d'].iloc[-1]:.2%}")
print(f"1-year volatility:  {df['returns'].std() * np.sqrt(252):.2%}")

# Value at Risk (95% confidence)
var_95 = df['returns'].quantile(0.05)
print(f"\nValue at Risk (95%): {var_95:.2%} daily loss")
print(f"Dollar VaR on $100k position: \\$\{abs(var_95 * 100000):.2f\}")

import pandas as pd
from statsmodels.tsa.seasonal import seasonal_decompose
from oilpriceapi import Client
from datetime import datetime, timedelta
import matplotlib.pyplot as plt

client = Client(api_key="your_api_key_here")

# Fetch 3 years of daily data
end_date = datetime.now()
start_date = end_date - timedelta(days=365 * 3)

data = client.get_historical_prices(
    by_code="WTI_USD",
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d")
)

df = pd.DataFrame(data['data'])
df['created_at'] = pd.to_datetime(df['created_at'])
df = df.set_index('created_at').sort_index()

# Resample to daily if intraday data
df_daily = df['price'].resample('D').mean().dropna()

# Seasonal decomposition
decomposition = seasonal_decompose(df_daily, model='additive', period=365)

# Plot components
fig, axes = plt.subplots(4, 1, figsize=(12, 10))

df_daily.plot(ax=axes[0], title='Original Price')
decomposition.trend.plot(ax=axes[1], title='Trend')
decomposition.seasonal.plot(ax=axes[2], title='Seasonal')
decomposition.resid.plot(ax=axes[3], title='Residual')

plt.tight_layout()
plt.savefig('seasonal_decomposition.png')
print("Seasonal decomposition saved to seasonal_decomposition.png")

# Print seasonal insights
seasonal = decomposition.seasonal
print("\nSeasonal Insights:")
print(f"Peak seasonal effect: {seasonal.max():.2f} in {seasonal.idxmax().strftime('%B')}")
print(f"Low seasonal effect:  {seasonal.min():.2f} in {seasonal.idxmin().strftime('%B')}")

import pandas as pd
from oilpriceapi import Client
from datetime import datetime, timedelta

client = Client(api_key="your_api_key_here")

# Fetch 5 years for backtesting
end_date = datetime.now()
start_date = end_date - timedelta(days=365 * 5)

data = client.get_historical_prices(
    by_code="WTI_USD",
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d")
)

df = pd.DataFrame(data['data'])
df['created_at'] = pd.to_datetime(df['created_at'])
df = df.set_index('created_at').sort_index()

# Calculate moving averages
df['MA_50'] = df['price'].rolling(window=50).mean()
df['MA_200'] = df['price'].rolling(window=200).mean()

# Generate signals
df['signal'] = 0
df.loc[df['MA_50'] > df['MA_200'], 'signal'] = 1  # Long signal
df.loc[df['MA_50'] < df['MA_200'], 'signal'] = -1  # Short signal

# Calculate position changes (trades)
df['position'] = df['signal'].shift()
df['trade'] = df['signal'].diff()

# Calculate returns
df['returns'] = df['price'].pct_change()
df['strategy_returns'] = df['position'] * df['returns']

# Performance metrics
total_return = (1 + df['strategy_returns']).prod() - 1
buy_hold_return = (df['price'].iloc[-1] / df['price'].iloc[0]) - 1
num_trades = (df['trade'] != 0).sum()

print("Backtest Results: MA(50) vs MA(200) Crossover")
print("=" * 50)
print(f"Strategy Return:    {total_return:.2%}")
print(f"Buy & Hold Return:  {buy_hold_return:.2%}")
print(f"Outperformance:     {(total_return - buy_hold_return):.2%}")
print(f"Number of Trades:   {num_trades}")

# Sharpe Ratio (annualized)
sharpe = df['strategy_returns'].mean() / df['strategy_returns'].std() * (252**0.5)
print(f"Sharpe Ratio:       {sharpe:.2f}")

# Max Drawdown
cumulative = (1 + df['strategy_returns']).cumprod()
running_max = cumulative.expanding().max()
drawdown = (cumulative - running_max) / running_max
max_drawdown = drawdown.min()
print(f"Max Drawdown:       {max_drawdown:.2%}")