1# Import required packages
2import requests
3import pandas as pd
4import numpy as np
5import matplotlib.pyplot as plt
6import seaborn as sns
7from datetime import datetime, timedelta
8import json
9import warnings
10warnings.filterwarnings('ignore')
11
12# Configure plotting style
13plt.style.use('default')
14sns.set_palette("husl")
15plt.rcParams['figure.figsize'] = (14, 10)
16plt.rcParams['font.size'] = 11
17plt.rcParams['axes.grid'] = True
18plt.rcParams['grid.alpha'] = 0.3
19
20# Configuration variables for CoinAPI Indexes API
21API_BASE_URL = "https://rest-api.indexes.coinapi.io/v1"
22INDEX_ID = "IDX_REFRATE_VWAP_BTC"
23PERIOD_ID = "1HRS"
24TIME_START = "2025-07-07T00:00:00"
25TIME_END = "2025-07-08T00:00:00"
26
27# API key configuration - Replace with your actual API key
28API_KEY = "YOUR_COINAPI_KEY_HERE"  # Replace with your actual API key
29
30# Validate API key
31if API_KEY == "YOUR_COINAPI_KEY_HERE":
32    print("WARNING: Please update your CoinAPI key before proceeding!")
33    print("Get your key from: https://www.coinapi.io/")
34else:
35    print("CoinAPI key configured successfully!")
36
37print(f"Base URL: {API_BASE_URL}")
38print(f"Index ID: {INDEX_ID}")
39print(f"Period: {PERIOD_ID}")
40print(f"Time Range: {TIME_START} to {TIME_END}")
41print("Environment setup complete!")
42

1# API endpoint configuration
2endpoint = f"{API_BASE_URL}/indexes/{INDEX_ID}/timeseries"
3
4# Query parameters
5params = {
6    'period_id': PERIOD_ID,
7    'time_start': TIME_START,
8    'time_end': TIME_END
9}
10
11# Headers for authentication
12headers = {
13    'X-CoinAPI-Key': API_KEY
14}
15
16print(f"API Endpoint: {endpoint}")
17print(f"Index ID: {INDEX_ID}")
18print(f"Time Period: {TIME_START} to {TIME_END}")
19print(f"Data Granularity: {PERIOD_ID}")
20
21# Make the API request
22try:
23    response = requests.get(endpoint, params=params, headers=headers)
24    response.raise_for_status()
25    
26    # Parse the response
27    data = response.json()
28    print(f"API request successful!")
29    print(f"Retrieved {len(data)} data points")
30    
31except requests.exceptions.RequestException as e:
32    print(f"API request failed: {e}")
33    if response.status_code == 401:
34        print("   This usually means an invalid or missing API key")
35    elif response.status_code == 429:
36        print("   Rate limit exceeded. Please wait before making another request")
37    data = []
38
39# Display sample data structure (first few records)
40if data:
41    print("Sample data structure:")
42    print(json.dumps(data[0], indent=2))

1# Convert API response to DataFrame
2if data:
3    df = pd.DataFrame(data)
4    
5    # Display initial DataFrame info
6    print("Initial DataFrame Info:")
7    print(f"Shape: {df.shape}")
8    print(f"Columns: {list(df.columns)}")
9    
10    # Convert timestamp to datetime
11    df['time_period_start'] = pd.to_datetime(df['time_period_start'])
12    df['time_period_end'] = pd.to_datetime(df['time_period_end'])
13    
14    # Sort by timestamp
15    df = df.sort_values('time_period_start').reset_index(drop=True)
16    
17    # Extract key metrics - using the correct field names from API response
18    df['vwap'] = df['value_close'].astype(float)  # Use value_close as VWAP
19    df['open_price'] = df['value_open'].astype(float)
20    df['high_price'] = df['value_high'].astype(float)
21    df['low_price'] = df['value_low'].astype(float)
22    
23    # Create additional time-based features
24    df['hour'] = df['time_period_start'].dt.hour
25    df['day_period'] = df['time_period_start'].dt.strftime('%Y-%m-%d')
26    
27    # Calculate price changes and returns
28    df['price_change'] = df['vwap'].diff()
29    df['price_change_pct'] = df['vwap'].pct_change() * 100
30    
31    # Calculate moving averages for trend analysis
32    df['vwap_ma_3'] = df['vwap'].rolling(window=3).mean()
33    df['vwap_ma_6'] = df['vwap'].rolling(window=6).mean()
34    
35    print("Data preparation complete!")
36    print(f"Time range: {df['time_period_start'].min()} to {df['time_period_start'].max()}")
37    print(f"VWAP range: ${df['vwap'].min():,.2f} to ${df['vwap'].max():,.2f}")
38    
39    # Display cleaned data
40    print("Cleaned DataFrame (first 5 rows):")
41    display_cols = ['time_period_start', 'vwap', 'open_price', 'high_price', 'low_price', 'price_change', 'price_change_pct']
42    print(df[display_cols].head())
43    
44else:
45    print("No data available for processing")
46    df = pd.DataFrame()

1if not df.empty:
2    # Basic statistics
3    print("VWAP Data Statistics:")
4    print("=" * 50)
5    
6    stats = df[['vwap', 'open_price', 'high_price', 'low_price', 'price_change', 'price_change_pct']].describe()
7    print(stats)
8    
9    # Time-based analysis
10    print("Time-based Analysis:")
11    print("=" * 50)
12    
13    # Hourly statistics
14    hourly_stats = df.groupby('hour').agg({
15        'vwap': ['mean', 'std', 'min', 'max'],
16        'open_price': 'mean',
17        'high_price': 'max',
18        'low_price': 'min',
19        'price_change_pct': 'mean'
20    }).round(2)
21    
22    print("Hourly VWAP Statistics:")
23    print(hourly_stats)
24    
25    # Trend identification
26    print("Trend Analysis:")
27    print("=" * 50)
28    
29    # Overall trend direction
30    first_vwap = df['vwap'].iloc[0]
31    last_vwap = df['vwap'].iloc[-1]
32    total_change = last_vwap - first_vwap
33    total_change_pct = (total_change / first_vwap) * 100
34    
35    print(f"Overall VWAP Change: ${total_change:,.2f} ({total_change_pct:+.2f}%)")
36    
37    if total_change > 0:
38        print("Overall Trend: BULLISH (Price increased)")
39    elif total_change < 0:
40        print("Overall Trend: BEARISH (Price decreased)")
41    else:
42        print("Overall Trend: SIDEWAYS (No change)")
43    
44    # Volatility analysis
45    volatility = df['price_change_pct'].std()
46    print(f"Volatility (Std Dev of Returns): {volatility:.2f}%")
47    
48    # Price range analysis (replacing volume analysis)
49    price_range = df['high_price'] - df['low_price']
50    avg_price_range = price_range.mean()
51    max_price_range = price_range.max()
52    print(f"Average Price Range: ${avg_price_range:,.2f}")
53    print(f"Maximum Price Range: ${max_price_range:,.2f}")
54    
55    # Additional insights
56    print("\nAdditional Market Insights:")
57    print("=" * 50)
58    
59    # Identify highest and lowest VWAP periods
60    max_vwap_idx = df['vwap'].idxmax()
61    min_vwap_idx = df['vwap'].idxmax()
62    
63    print(f"Highest VWAP: ${df.loc[max_vwap_idx, 'vwap']:,.2f} at {df.loc[max_vwap_idx, 'time_period_start'].strftime('%H:%M')}")
64    print(f"Lowest VWAP: ${df.loc[min_vwap_idx, 'vwap']:,.2f} at {df.loc[min_vwap_idx, 'time_period_start'].strftime('%H:%M')}")
65    
66    # Calculate average hourly price change
67    avg_hourly_change = df['price_change_pct'].mean()
68    print(f"Average Hourly Price Change: {avg_hourly_change:+.2f}%")
69    
70else:
71    print("No data available for exploration")

1if not df.empty:
2    print("VWAP Trend Analysis:")
3    print("=" * 50)
4    
5    # Identify trend changes
6    df['trend'] = 'neutral'
7    df.loc[df['vwap'] > df['vwap_ma_3'], 'trend'] = 'bullish'
8    df.loc[df['vwap'] < df['vwap_ma_3'], 'trend'] = 'bearish'
9    
10    # Count trend periods
11    trend_counts = df['trend'].value_counts()
12    print("Trend Distribution:")
13    for trend, count in trend_counts.items():
14        percentage = (count / len(df)) * 100
15        print(f"  {trend.capitalize()}: {count} periods ({percentage:.1f}%)")
16    
17    # Identify support and resistance levels
18    print("Support and Resistance Analysis:")
19    
20    # Support levels (local minima)
21    support_levels = []
22    for i in range(1, len(df) - 1):
23        if (df['vwap'].iloc[i] < df['vwap'].iloc[i-1] and 
24            df['vwap'].iloc[i] < df['vwap'].iloc[i+1]):
25            support_levels.append({
26                'time': df['time_period_start'].iloc[i],
27                'price': df['vwap'].iloc[i],
28                'price_range': df['high_price'].iloc[i] - df['low_price'].iloc[i]
29            })
30    
31    # Resistance levels (local maxima)
32    resistance_levels = []
33    for i in range(1, len(df) - 1):
34        if (df['vwap'].iloc[i] > df['vwap'].iloc[i-1] and 
35            df['vwap'].iloc[i] > df['vwap'].iloc[i+1]):
36            resistance_levels.append({
37                'time': df['time_period_start'].iloc[i],
38                'price': df['vwap'].iloc[i],
39                'price_range': df['high_price'].iloc[i] - df['low_price'].iloc[i]
40            })
41    
42    print(f"  Support Levels Found: {len(support_levels)}")
43    print(f"  Resistance Levels Found: {len(resistance_levels)}")
44    
45    # Display key levels
46    if support_levels:
47        print("  Key Support Levels:")
48        for level in sorted(support_levels, key=lambda x: x['price'])[:3]:
49            print(f"    ${level['price']:,.2f} at {level['time'].strftime('%H:%M')}")
50    
51    if resistance_levels:
52        print("  Key Resistance Levels:")
53        for level in sorted(resistance_levels, key=lambda x: x['price'], reverse=True)[:3]:
54            print(f"    ${level['price']:,.2f} at {level['time'].strftime('%H:%M')}")
55    
56    # Price range analysis (replacing volume analysis)
57    print("Price Range Analysis:")
58    
59    # High price range periods
60    price_range = df['high_price'] - df['low_price']
61    range_threshold = price_range.quantile(0.75)
62    high_range_periods = df[price_range > range_threshold]
63    
64    if not high_range_periods.empty:
65        avg_price_change_high_range = high_range_periods['price_change_pct'].mean()
66        print(f"  High Range Periods (>75th percentile): {len(high_range_periods)} periods")
67        print(f"  Average Price Change in High Range: {avg_price_change_high_range:+.2f}%")
68    
69    # Momentum analysis
70    print("Momentum Analysis:")
71    
72    # Calculate momentum indicators
73    df['momentum'] = df['vwap'] - df['vwap'].shift(3)
74    df['momentum_pct'] = (df['momentum'] / df['vwap'].shift(3)) * 100
75    
76    current_momentum = df['momentum_pct'].iloc[-1]
77    print(f"  Current 3-period Momentum: {current_momentum:+.2f}%")
78    
79    if current_momentum > 0:
80        print("  Momentum is positive (bullish)")
81    else:
82        print("  Momentum is negative (bearish)")
83    
84else:
85    print("No data available for analysis")

1if not df.empty:
2    # Create a comprehensive visualization
3    fig, axes = plt.subplots(3, 1, figsize=(16, 14))
4    fig.suptitle('Bitcoin VWAP Intraday Analysis - Market Trends and Patterns', 
5                 fontsize=16, fontweight='bold')
6    
7    # Plot 1: VWAP Price with Moving Averages and Trend
8    ax1 = axes[0]
9    ax1.plot(df['time_period_start'], df['vwap'], 'b-', linewidth=2, label='VWAP', alpha=0.8)
10    ax1.plot(df['time_period_start'], df['vwap_ma_3'], 'r--', linewidth=1.5, label='3-Period MA', alpha=0.7)
11    ax1.plot(df['time_period_start'], df['vwap_ma_6'], 'g--', linewidth=1.5, label='6-Period MA', alpha=0.7)
12    
13    # Color code by trend
14    for i in range(len(df)):
15        if df['trend'].iloc[i] == 'bullish':
16            ax1.scatter(df['time_period_start'].iloc[i], df['vwap'].iloc[i], 
17                       color='green', s=30, alpha=0.6)
18        elif df['trend'].iloc[i] == 'bearish':
19            ax1.scatter(df['time_period_start'].iloc[i], df['vwap'].iloc[i], 
20                       color='red', s=30, alpha=0.6)
21    
22    # Add support and resistance levels
23    if support_levels:
24        support_prices = [level['price'] for level in support_levels]
25        support_times = [level['time'] for level in support_levels]
26        ax1.scatter(support_times, support_prices, color='blue', s=100, 
27                   marker='^', label='Support Levels', zorder=5)
28    
29    if resistance_levels:
30        resistance_prices = [level['price'] for level in resistance_levels]
31        resistance_times = [level['time'] for level in resistance_levels]
32        ax1.scatter(resistance_times, resistance_prices, color='red', s=100, 
33                   marker='v', label='Resistance Levels', zorder=5)
34    
35    ax1.set_title('VWAP Price Action with Trend Indicators', fontweight='bold')
36    ax1.set_ylabel('VWAP Price (USD)', fontweight='bold')
37    ax1.legend()
38    ax1.grid(True, alpha=0.3)
39    
40    # Plot 2: Price Range Analysis (replacing Volume Analysis)
41    ax2 = axes[1]
42    price_range = df['high_price'] - df['low_price']
43    bars = ax2.bar(df['time_period_start'], price_range, alpha=0.7, 
44                   color='skyblue', edgecolor='navy', linewidth=0.5)
45    
46    # Highlight high range periods
47    if not high_range_periods.empty:
48        high_range_times = high_range_periods['time_period_start']
49        high_range_values = high_range_periods['high_price'] - high_range_periods['low_price']
50        ax2.bar(high_range_times, high_range_values, color='orange', 
51               alpha=0.8, label='High Range Periods')
52    
53    ax2.set_title('Price Range by Hour (High-Low Spread)', fontweight='bold')
54    ax2.set_ylabel('Price Range (USD)', fontweight='bold')
55    ax2.legend()
56    ax2.grid(True, alpha=0.3)
57    
58    # Plot 3: Price Changes and Momentum
59    ax3 = axes[2]
60    
61    # Price changes
62    colors = ['green' if x > 0 else 'red' if x < 0 else 'gray' for x in df['price_change_pct']]
63    bars3 = ax3.bar(df['time_period_start'], df['price_change_pct'], 
64                    color=colors, alpha=0.7, edgecolor='black', linewidth=0.5)
65    
66    # Add momentum line
67    ax3_twin = ax3.twinx()
68    ax3_twin.plot(df['time_period_start'], df['momentum_pct'], 'purple', 
69                  linewidth=2, label='3-Period Momentum', alpha=0.8)
70    
71    ax3.set_title('Price Changes and Momentum', fontweight='bold')
72    ax3.set_ylabel('Price Change (%)', fontweight='bold')
73    ax3_twin.set_ylabel('Momentum (%)', fontweight='bold', color='purple')
74    ax3.axhline(y=0, color='black', linestyle='-', alpha=0.5)
75    ax3.grid(True, alpha=0.3)
76    
77    # Format x-axis for all subplots
78    for ax in axes:
79        ax.xaxis.set_major_formatter(plt.matplotlib.dates.DateFormatter('%H:%M'))
80        ax.tick_params(axis='x', rotation=45)
81    
82    plt.tight_layout()
83    plt.show()
84    
85    # Create summary statistics table
86    print("Summary Statistics Table:")
87    print("=" * 80)
88    
89    summary_data = {
90        'Metric': [
91            'Total Periods',
92            'Starting VWAP',
93            'Ending VWAP',
94            'Total Change',
95            'Total Change %',
96            'Average Price Range',
97            'Volatility (Std Dev)',
98            'Bullish Periods',
99            'Bearish Periods',
100            'Support Levels',
101            'Resistance Levels',
102            'Current Momentum'
103        ],
104        'Value': [
105            len(df),
106            f"${df['vwap'].iloc[0]:,.2f}",
107            f"${df['vwap'].iloc[-1]:,.2f}",
108            f"${total_change:+,.2f}",
109            f"{total_change_pct:+.2f}%",
110            f"${price_range.mean():,.2f}",
111            f"{df['price_change_pct'].std():.2f}%",
112            f"{trend_counts.get('bullish', 0)} ({trend_counts.get('bullish', 0)/len(df)*100:.1f}%)",
113            f"{trend_counts.get('bearish', 0)} ({trend_counts.get('bearish', 0)/len(df)*100:.1f}%)",
114            len(support_levels),
115            len(resistance_levels),
116            f"{current_momentum:+.2f}%"
117        ]
118    }
119    
120    summary_df = pd.DataFrame(summary_data)
121    print(summary_df.to_string(index=False))
122    
123else:
124    print("No data available for visualization")