polygon.io vs alpha vantage - which data feed for algo trading

from polygon import RESTClient
from polygon import WebSocketClient
import asyncio

# REST client for historical data
rest_client = RESTClient(api_key="YOUR_KEY")

def get_historical_bars(symbol, from_date, to_date):
    """
    Get historical daily bars from Polygon
    """
    aggs = rest_client.get_aggs(
        ticker=symbol,
        multiplier=1,
        timespan="day",
        from_=from_date,
        to=to_date,
        limit=50000
    )

    bars = []
    for agg in aggs:
        bars.append({
            'timestamp': agg.timestamp,
            'open': agg.open,
            'high': agg.high,
            'low': agg.low,
            'close': agg.close,
            'volume': agg.volume
        })

    return bars

# Websocket client for real-time data
def handle_msg(msgs):
    """Process real-time messages"""
    for msg in msgs:
        if msg['ev'] == 'A':  # Aggregate (bar)
            print(f"Symbol: {msg['sym']}")
            print(f"Close: ${msg['c']:.2f}")
            print(f"Volume: {msg['v']:,}")

async def run_websocket():
    """Real-time data stream"""
    ws = WebSocketClient(
        api_key="YOUR_KEY",
        feed='stocks',
        on_message=handle_msg
    )

    # Subscribe to SPY 1-minute bars
    ws.subscribe('A.SPY')

    await ws.run()

# Usage
historical = get_historical_bars('SPY', '2023-01-01', '2024-02-11')
print(f"Retrieved {len(historical)} bars")

# Real-time streaming
asyncio.run(run_websocket())

import requests
import time

ALPHA_VANTAGE_KEY = "YOUR_KEY"

def get_intraday_data(symbol, interval='5min'):
    """
    Get intraday bars from Alpha Vantage
    Rate limited to 5 calls per minute
    """
    url = f"https://www.alphavantage.co/query"
    params = {
        'function': 'TIME_SERIES_INTRADAY',
        'symbol': symbol,
        'interval': interval,
        'apikey': ALPHA_VANTAGE_KEY,
        'outputsize': 'full'
    }

    response = requests.get(url, params=params)
    data = response.json()

    # Check for rate limit
    if 'Note' in data:
        print("Rate limit hit - waiting 60 seconds")
        time.sleep(60)
        return get_intraday_data(symbol, interval)

    # Parse time series
    time_series = data.get(f'Time Series ({interval})', {})

    bars = []
    for timestamp, values in time_series.items():
        bars.append({
            'timestamp': timestamp,
            'open': float(values['1. open']),
            'high': float(values['2. high']),
            'low': float(values['3. low']),
            'close': float(values['4. close']),
            'volume': int(values['5. volume'])
        })

    return bars

def get_daily_data(symbol):
    """
    Get daily historical data
    Full history (20+ years available)
    """
    url = f"https://www.alphavantage.co/query"
    params = {
        'function': 'TIME_SERIES_DAILY_ADJUSTED',
        'symbol': symbol,
        'apikey': ALPHA_VANTAGE_KEY,
        'outputsize': 'full'
    }

    response = requests.get(url, params=params)
    data = response.json()

    time_series = data.get('Time Series (Daily)', {})

    bars = []
    for timestamp, values in time_series.items():
        bars.append({
            'timestamp': timestamp,
            'open': float(values['1. open']),
            'high': float(values['2. high']),
            'low': float(values['3. low']),
            'close': float(values['4. close']),
            'adjusted_close': float(values['5. adjusted close']),
            'volume': int(values['6. volume'])
        })

    return bars

# Usage with rate limit handling
spy_intraday = get_intraday_data('SPY', '5min')
print(f"Retrieved {len(spy_intraday)} 5-minute bars")

time.sleep(12)  # Wait for rate limit (5 calls/min = 12 sec between)

spy_daily = get_daily_data('SPY')
print(f"Retrieved {len(spy_daily)} daily bars")

import time
from datetime import datetime

class RateLimitedClient:
    """
    Wrapper for Alpha Vantage with automatic rate limiting
    """
    def __init__(self, api_key, calls_per_minute=5):
        self.api_key = api_key
        self.calls_per_minute = calls_per_minute
        self.min_interval = 60.0 / calls_per_minute  # Seconds between calls
        self.last_call_time = 0

    def call_api(self, url, params):
        """
        Make API call with automatic rate limiting
        """
        # Calculate wait time
        elapsed = time.time() - self.last_call_time
        if elapsed < self.min_interval:
            wait_time = self.min_interval - elapsed
            print(f"Rate limit: waiting {wait_time:.1f} seconds")
            time.sleep(wait_time)

        # Make call
        params['apikey'] = self.api_key
        response = requests.get(url, params=params)

        # Update last call time
        self.last_call_time = time.time()

        return response.json()

# Usage
client = RateLimitedClient(api_key="YOUR_KEY", calls_per_minute=5)

# This will automatically space calls 12 seconds apart
for symbol in ['SPY', 'QQQ', 'IWM', 'DIA', 'GLD']:
    data = client.call_api(
        "https://www.alphavantage.co/query",
        {'function': 'TIME_SERIES_DAILY', 'symbol': symbol}
    )
    print(f"Retrieved {symbol} data")