FIRE 75.0046 ✨Fornitori dei dati

NO, per le azioni NASDAQ, TradingView usa principalmente la borsa NASDAQ stessa.

DETTAGLI SUI FORNITORI PER NASDAQ:

1. FONTE PRIMARIA (REAL-TIME):

Nasdaq Last Sale (NLS) - Dati ufficiali della borsa NASDAQ
Nasdaq Basic - Per utenti professionali
Nasdaq TotalView - Livello II (market depth)

2. FONTI SECONDARIE:

Cboe BZX (solo per alcune azioni cross-listed)
NYSE (per azioni dual-listed come MSFT)
IEX (solo per alcuni simboli)

3. PER DATI RITARDATI (15-min):

Cboe BZX (gratuito, 15-min delay)
Nasdaq Basic Delayed

COME OTTENERE GLI STESSI DATI:

OPZIONE 1: NASDAQ DATA LINK (GRATIS PER RITARDATI)

import nasdaqdatalink
import pandas as pd
 
# Chiave API gratis: registrati su data.nasdaq.com
nasdaqdatalink.ApiConfig.api_key = "tuo_api_key"
 
# Dati storici Apple (NASDAQ:AAPL)
# EOD (End of Day) - dati giornalieri ritardati
data = nasdaqdatalink.get("EOD/AAPL", start_date="2023-01-01")
print(data.head())

OPZIONE 2: POLYGON.IO (MIGLIORE QUALITÀ/PREZZO)

import requests
import pandas as pd
 
class NasdaqDataFetcher:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.polygon.io"
    
    def get_nasdaq_stock(self, symbol, start_date, end_date):
        """Ottiene dati NASDAQ identici a TradingView"""
        url = f"{self.base_url}/v2/aggs/ticker/{symbol}/range/1/day/{start_date}/{end_date}"
        params = {
            "adjusted": "true",
            "sort": "asc",
            "apiKey": self.api_key
        }
        
        response = requests.get(url, params=params)
        data = response.json()
        
        if data.get("results"):
            df = pd.DataFrame(data["results"])
            df["t"] = pd.to_datetime(df["t"], unit="ms")  # Timestamp
            df.columns = ["volume", "vwap", "open", "close", "high", "low", "timestamp", "transactions"]
            return df
        
        return None
 
# Esempio: Apple (AAPL)
fetcher = NasdaqDataFetcher("tuo_api_key_polygon")
data = fetcher.get_nasdaq_stock("AAPL", "2023-01-01", "2023-12-31")

OPZIONE 3: DIRECT NASDAQ API (COSTOSA)

# Per dati real-time professionali
# Costo: $500-5000/mese
# Richiede contratto diretto con NASDAQ

OPZIONE 4: IEX CLOUD (GRATIS PER RITARDATI)

import requests
 
def get_iex_nasdaq_data(symbol, timeframe="1d"):
    """Dati NASDAQ con 15-min delay (gratis)"""
    url = f"https://cloud.iexapis.com/stable/stock/{symbol}/chart/{timeframe}"
    params = {
        "token": "tuo_api_key_iex",  # Gratis: registrati su iexcloud.io
        "chartCloseOnly": "false"
    }
    
    response = requests.get(url, params=params)
    return pd.DataFrame(response.json())

CONFRONTO FORNITORI:

Fornitore	Dati	Delay	Costo/Mese	Limiti
Nasdaq Data Link	EOD (giornaliero)	1 giorno	Gratis	50 req/giorno
Polygon.io	Real-time + storici	0-15 min	$7-79	5-200 req/min
IEX Cloud	Real-time + ritardati	15 min	Gratis-$9	50K-500K msg/mese
Yahoo Finance	Ritardati	15 min	Gratis	Nessuno
Alpha Vantage	Ritardati	15 min	Gratis	5 req/min

IL MIO CONSIGLIO:

Se ti bastano dati ritardati (15-min):

# Yahoo Finance - Completamente gratis
import yfinance as yf
 
aapl = yf.Ticker("AAPL")
hist = aapl.history(period="max", interval="1d")
hist.to_csv("AAPL_historical.csv")

Se vuoi dati real-time professionali:

# Polygon.io - $7/mese
import polygon
 
client = polygon.RESTClient("tuo_api_key")
aggs = client.get_aggs(
    "AAPL", 
    multiplier=1, 
    timespan="day", 
    from_="2023-01-01", 
    to="2023-12-31"
)

CODICE COMPLETO SEMPLIFICATO:

# nasdaq_data_fetcher.py
import yfinance as yf
import pandas as pd
from datetime import datetime
import os
 
class NasdaqDataDownloader:
    """Scarica dati NASDAQ identici a TradingView"""
    
    def __init__(self, use_polygon=False, api_key=None):
        self.use_polygon = use_polygon
        self.api_key = api_key
        
    def download(self, symbol, start_date, end_date, interval="1d"):
        """Scarica dati storici"""
        
        if self.use_polygon and self.api_key:
            return self._download_polygon(symbol, start_date, end_date, interval)
        else:
            return self._download_yahoo(symbol, start_date, end_date, interval)
    
    def _download_yahoo(self, symbol, start_date, end_date, interval):
        """Yahoo Finance (gratis, 15-min delay)"""
        try:
            ticker = yf.Ticker(symbol)
            df = ticker.history(start=start_date, end=end_date, interval=interval)
            
            # Rinomina colonne come TradingView
            df = df.rename(columns={
                'Open': 'open',
                'High': 'high', 
                'Low': 'low',
                'Close': 'close',
                'Volume': 'volume'
            })
            
            df.index.name = 'timestamp'
            return df.reset_index()
            
        except Exception as e:
            print(f"Errore Yahoo Finance: {e}")
            return None
    
    def _download_polygon(self, symbol, start_date, end_date, interval):
        """Polygon.io (real-time, a pagamento)"""
        try:
            import requests
            
            # Mappa intervalli
            interval_map = {
                '1d': 'day',
                '1h': 'hour', 
                '15m': 'minute',
                '5m': 'minute',
                '1m': 'minute'
            }
            
            url = f"https://api.polygon.io/v2/aggs/ticker/{symbol}/range/1/{interval_map[interval]}/{start_date}/{end_date}"
            params = {"adjusted": "true", "sort": "asc", "apiKey": self.api_key}
            
            response = requests.get(url, params=params)
            data = response.json()
            
            if data.get("results"):
                df = pd.DataFrame(data["results"])
                df["timestamp"] = pd.to_datetime(df["t"], unit="ms")
                df = df.rename(columns={
                    "o": "open",
                    "h": "high",
                    "l": "low", 
                    "c": "close",
                    "v": "volume"
                })
                return df[["timestamp", "open", "high", "low", "close", "volume"]]
                
        except Exception as e:
            print(f"Errore Polygon: {e}")
            return None
    
    def save_to_csv(self, df, symbol):
        """Salva in CSV"""
        if df is not None:
            os.makedirs("nasdaq_data", exist_ok=True)
            filename = f"nasdaq_data/{symbol}_{datetime.now().strftime('%Y%m%d')}.csv"
            df.to_csv(filename, index=False)
            print(f"Dati salvati in {filename}")
            return filename
        return None
 
# USO
downloader = NasdaqDataDownloader()
 
# Scarica Apple gratis (15-min delay)
data = downloader.download(
    symbol="AAPL",
    start_date="2023-01-01",
    end_date="2023-12-31",
    interval="1d"
)
 
# Salva
downloader.save_to_csv(data, "AAPL")

VUOI CHE:

Implementiamo questo sistema con Yahoo Finance (gratis, ora)?
Proviamo Polygon.io (richiede API key, $7/mese)?
Paragoniamo i dati tra varie fonti?

Raccomandazione: Inizia con Yahoo Finance, poi se hai bisogno di real-time passa a Polygon. I dati storici sono identici.

Quartz 4

Explorer