Physical Flows REST API

const API_TOKEN = 'YOUR_API_TOKEN';

async function analyzePhysicalFlows(from, to, dateFrom, dateTo) {
  const response = await fetch(
    'https://api.cernion.de/api/entsoe/physical-flows',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_TOKEN}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        fromCountry: from,
        toCountry: to,
        dateFrom,
        dateTo,
        includeStatistics: true
      })
    }
  );
  
  const data = await response.json();
  
  console.log(`\n=== Physical Flows: ${data.border.from} → ${data.border.to} ===`);
  console.log(`Period: ${dateFrom} to ${dateTo}\n`);
  
  const stats = data.statistics;
  console.log('Flow Statistics:');
  console.log(`  Average: ${stats.avgFlow.toFixed(0)} MW`);
  console.log(`  Peak: ${stats.maxFlow.toFixed(0)} MW`);
  console.log(`  Net Export: ${stats.netExportMWh.toFixed(0)} MWh`);
  console.log(`  Export Hours: ${stats.exportHours}h | Import Hours: ${stats.importHours}h\n`);
  
  console.log('Congestion Analysis:');
  console.log(`  NTC Capacity: ${data.capacity.ntc} MW`);
  console.log(`  Avg Utilization: ${data.capacity.utilizationAvg.toFixed(1)}%`);
  console.log(`  Congestion Rate: ${stats.congestionRate.toFixed(1)}% (${stats.congestionHours}h)\n`);
  
  // Congestion Alert
  if (stats.congestionRate > 20) {
    console.warn(`⚠️ HIGH CONGESTION: ${stats.congestionRate.toFixed(1)}% - Trading opportunities limited!`);
  }
  
  // Net Flow Assessment
  const netDirection = stats.netExport > 0 ? 'Net Exporter' : 'Net Importer';
  console.log(`${data.border.from} is ${netDirection} to ${data.border.to}`);
  
  return data;
}

// Multi-Border Analysis for Germany
async function analyzeGermanyBorders() {
  const borders = [
    ['Germany', 'Austria'],
    ['Germany', 'France'],
    ['Germany', 'Poland'],
    ['Germany', 'Netherlands'],
    ['Germany', 'Switzerland']
  ];
  
  const dateFrom = '2026-02-01';
  const dateTo = '2026-02-07';
  
  console.log('\n=== Germany Cross-Border Analysis ===\n');
  
  for (const [from, to] of borders) {
    const data = await analyzePhysicalFlows(from, to, dateFrom, dateTo);
    const net = data.statistics.netExportMWh;
    const direction = net > 0 ? '→ Export' : '← Import';
    console.log(`${to.padEnd(15)} ${direction.padStart(10)}: ${Math.abs(net).toFixed(0).padStart(6)} MWh`);
  }
}

analyzePhysicalFlows('Germany', 'Austria', '2026-02-01', '2026-02-07');

import requests
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

API_TOKEN = 'YOUR_API_TOKEN'

class PhysicalFlowsAnalyzer:
    def __init__(self, api_token):
        self.api_token = api_token
        self.base_url = 'https://api.cernion.de/api/entsoe'
    
    def get_flows(self, from_country, to_country, date_from, date_to):
        """Fetch physical flows data"""
        response = requests.post(
            f'{self.base_url}/physical-flows',
            headers={
                'Authorization': f'Bearer {self.api_token}',
                'Content-Type': 'application/json'
            },
            json={
                'fromCountry': from_country,
                'toCountry': to_country,
                'dateFrom': date_from,
                'dateTo': date_to,
                'includeStatistics': True
            }
        )
        
        return response.json()
    
    def analyze_border(self, from_country, to_country, date_from, date_to):
        """Comprehensive border analysis"""
        data = self.get_flows(from_country, to_country, date_from, date_to)
        
        print(f'\n=== {data["border"]["from"]} → {data["border"]["to"]} ===')
        print(f'Period: {date_from} to {date_to}')
        
        stats = data['statistics']
        capacity = data['capacity']
        
        print(f'\n📊 Flow Statistics:')
        print(f'  Average Flow: {stats["avgFlow"]:.0f} MW')
        print(f'  Peak Flow: {stats["maxFlow"]:.0f} MW')
        print(f'  Min Flow: {stats["minFlow"]:.0f} MW')
        print(f'  Net Export: {stats["netExportMWh"]:.0f} MWh')
        
        print(f'\n⚡ Directional Analysis:')
        export_pct = (stats['exportHours'] / (stats['exportHours'] + stats['importHours'])) * 100
        print(f'  Export Hours: {stats["exportHours"]}h ({export_pct:.1f}%)')
        print(f'  Import Hours: {stats["importHours"]}h ({100-export_pct:.1f}%)')
        
        print(f'\n🚧 Congestion:')
        print(f'  NTC Capacity: {capacity["ntc"]} MW')
        print(f'  Avg Utilization: {capacity["utilizationAvg"]:.1f}%')
        print(f'  Max Utilization: {capacity["utilizationMax"]:.1f}%')
        print(f'  Congestion Rate: {stats["congestionRate"]:.1f}% ({stats["congestionHours"]}h)')
        
        if stats['congestionRate'] > 25:
            print(f'\n⚠️ HIGH CONGESTION: Trading capacity limited!')
        
        return data
    
    def compare_german_borders(self, date_from='2026-02-01', date_to='2026-02-07'):
        """Compare all German cross-border flows"""
        borders = [
            ('Germany', 'Austria'),
            ('Germany', 'France'),
            ('Germany', 'Poland'),
            ('Germany', 'Netherlands'),
            ('Germany', 'Switzerland'),
            ('Germany', 'Denmark'),
            ('Germany', 'Czech Republic')
        ]
        
        results = []
        
        for from_c, to_c in borders:
            try:
                data = self.get_flows(from_c, to_c, date_from, date_to)
                stats = data['statistics']
                capacity = data['capacity']
                
                results.append({
                    'Border': f'{from_c[:2]} → {to_c[:2]}',
                    'To Country': to_c,
                    'Avg Flow MW': stats['avgFlow'],
                    'Net Export MWh': stats['netExportMWh'],
                    'Export Hours': stats['exportHours'],
                    'Import Hours': stats['importHours'],
                    'NTC MW': capacity['ntc'],
                    'Utilization %': capacity['utilizationAvg'],
                    'Congestion %': stats['congestionRate']
                })
            except Exception as e:
                print(f'Error: {from_c} → {to_c}: {e}')
        
        df = pd.DataFrame(results)
        
        # Sort by Net Export (highest export first)
        df = df.sort_values('Net Export MWh', ascending=False)
        
        print('\n=== Germany Cross-Border Summary ===')
        print(df.to_string(index=False))
        
        # Net position
        total_net = df['Net Export MWh'].sum()
        print(f'\nGermany Net Position: {total_net:.0f} MWh')
        print(f'Status: {"NET EXPORTER" if total_net > 0 else "NET IMPORTER"}')
        
        # Congestion hotspots
        congested = df[df['Congestion %'] > 20]
        if len(congested) > 0:
            print(f'\n⚠️ Congested Borders (>20%):')
            print(congested[['Border', 'Congestion %', 'NTC MW']].to_string(index=False))
        
        return df
    
    def plot_flows(self, from_country, to_country, date_from, date_to):
        """Visualize flow patterns"""
        data = self.get_flows(from_country, to_country, date_from, date_to)
        
        df = pd.DataFrame(data['flows'])
        df['timestamp'] = pd.to_datetime(df['timestamp'])
        df['hour'] = df['timestamp'].dt.hour
        
        fig, axes = plt.subplots(2, 1, figsize=(12, 8))
        
        # Time series
        axes[0].plot(df['timestamp'], df['flow'], linewidth=0.8)
        axes[0].axhline(y=0, color='r', linestyle='--', alpha=0.5)
        axes[0].axhline(y=data['capacity']['ntc'], color='orange', linestyle='--', alpha=0.5, label='NTC Capacity')
        axes[0].set_title(f'Physical Flows: {data["border"]["from"]} → {data["border"]["to"]}')
        axes[0].set_ylabel('Flow (MW)')
        axes[0].legend()
        axes[0].grid(True, alpha=0.3)
        
        # Hourly average
        hourly_avg = df.groupby('hour')['flow'].mean()
        axes[1].bar(hourly_avg.index, hourly_avg.values, color='steelblue')
        axes[1].axhline(y=0, color='r', linestyle='--', alpha=0.5)
        axes[1].set_title('Average Flow by Hour')
        axes[1].set_xlabel('Hour of Day')
        axes[1].set_ylabel('Avg Flow (MW)')
        axes[1].grid(True, alpha=0.3, axis='y')
        
        plt.tight_layout()
        plt.savefig(f'flows_{from_country}_{to_country}.png')
        print(f'\nChart saved: flows_{from_country}_{to_country}.png')

if __name__ == '__main__':
    analyzer = PhysicalFlowsAnalyzer(API_TOKEN)
    
    # Single border analysis
    analyzer.analyze_border('Germany', 'Austria', '2026-02-01', '2026-02-07')
    
    # Multi-border comparison
    df = analyzer.compare_german_borders()
    
    # Export
    df.to_csv('german_borders.csv', index=False)
    
    # Visualization
    analyzer.plot_flows('Germany', 'Austria', '2026-02-01', '2026-02-07')