0Pricing
AI Agents · Lezione

Integrazione delle API per i dati di mercato

Alpha Vantage, Yahoo Finance e Polygon.io per dati in tempo reale e storici.

Integrazione delle API per i dati di mercato è una lezione AI Agents gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Agents, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Agents include 4 lezioni in totale.

Dati di mercato negli agenti finanziari

Gli agenti di analisi finanziaria devono avere accesso ai dati di mercato in tempo reale e storici. I tipi di dati più comuni includono OHLCV (Open/High/Low/Close/Volume), le date degli utili, i rapporti fondamentali e le catene di opzioni.

Diverse API forniscono questi dati: yfinance (gratuita, Yahoo Finance), Polygon.io (a pagamento, affidabile) e Alpha Vantage (con un piano gratuito disponibile).

yfinance: dati storici sui prezzi

yfinance funge da wrapper per l'API di Yahoo Finance ed è il modo più rapido per iniziare. Ticker.history() restituisce un DataFrame pandas contenente dati OHLCV.

import yfinance as yf

ticker = yf.Ticker('AAPL')

# 1 year of daily data
history = ticker.history(period='1y')
print(history.tail(3))
#                  Open        High         Low       Close    Volume
# Date
# 2026-05-27  189.1500  190.3200  188.9200  190.0500  55234000
# 2026-05-28  190.4200  191.5600  189.7800  191.1200  62345000
print(f'Rows: {len(history)}')

yfinance: intervalli di date personalizzati

Utilizzi i parametri start e end per definire intervalli di date personalizzati, oppure interval per i dati intraday (1m, 5m, 1h). Tenga presente che, a seconda dell'intervallo, i dati intraday sono limitati agli ultimi 60 giorni.

import yfinance as yf

ticker = yf.Ticker('MSFT')

# Custom date range
history = ticker.history(start='2024-01-01', end='2024-12-31')
print(f'Trading days in 2024: {len(history)}')

# Batch multiple tickers
tickers = yf.download(['AAPL', 'MSFT', 'GOOGL'],
                       start='2025-01-01', end='2025-12-31')
print(tickers['Close'].head())

API REST di Polygon.io

Polygon.io fornisce dati di mercato di livello professionale, con limiti di frequenza più elevati e un'operatività più affidabile rispetto alle fonti gratuite. Lo utilizzi per gli agenti finanziari destinati alla produzione.

import requests

POLYGON_KEY = 'YOUR_POLYGON_API_KEY'

def get_polygon_daily(ticker: str, from_date: str, to_date: str) -> list[dict]:
    url = f'https://api.polygon.io/v2/aggs/ticker/{ticker}/range/1/day/{from_date}/{to_date}'
    resp = requests.get(url, params={'apiKey': POLYGON_KEY, 'limit': 365})
    resp.raise_for_status()
    data = resp.json()
    return data.get('results', [])

bars = get_polygon_daily('AAPL', '2025-01-01', '2025-12-31')
print(f'Bars returned: {len(bars)}')
if bars:
    print('Latest close:', bars[-1]['c'])

TIME_SERIES_DAILY di Alpha Vantage

Alpha Vantage offre un piano gratuito (25 chiamate al giorno) e un piano a pagamento. L'endpoint TIME_SERIES_DAILY restituisce dati OHLCV con prezzi rettificati facoltativi.

import requests

ALPHA_KEY = 'YOUR_ALPHA_VANTAGE_KEY'

def get_alpha_vantage_daily(symbol: str, outputsize: str = 'compact') -> dict:
    # outputsize: 'compact' (100 days) or 'full' (20+ years)
    resp = requests.get('https://www.alphavantage.co/query', params={
        'function':   'TIME_SERIES_DAILY_ADJUSTED',
        'symbol':     symbol,
        'outputsize': outputsize,
        'apikey':     ALPHA_KEY
    })
    resp.raise_for_status()
    data = resp.json()
    series = data.get('Time Series (Daily)', {})
    return series   # dict: {date_str: {open, high, low, close, volume, ...}}

Limiti di frequenza e logica di ritentativo

Tutte le API per i dati di mercato applicano limiti di frequenza. Se li supera, riceve l'errore 429 (Too Many Requests). Implementi sempre un backoff esponenziale e rispetti i limiti.

import time, requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def make_rate_limited_session(calls_per_minute: int = 5) -> requests.Session:
    session = requests.Session()
    retry = Retry(
        total=3,
        backoff_factor=2,         # 1s, 2s, 4s waits
        status_forcelist=[429, 500, 502, 503, 504]
    )
    adapter = HTTPAdapter(max_retries=retry)
    session.mount('https://', adapter)
    session._calls_per_min = calls_per_minute
    session._min_interval  = 60.0 / calls_per_minute
    session._last_call     = 0.0
    return session

def rate_limited_get(session, url, **kwargs):
    elapsed = time.time() - session._last_call
    if elapsed < session._min_interval:
        time.sleep(session._min_interval - elapsed)
    session._last_call = time.time()
    return session.get(url, **kwargs)

Memorizzare nella cache i dati di mercato

I dati storici sono immutabili: il prezzo di chiusura di ieri non cambia mai. Li memorizzi nella cache per evitare chiamate API ridondanti. Utilizzi una semplice cache su disco con chiave composta da (ticker, date_range).

import hashlib, json, os

CACHE_DIR = '/tmp/market_cache'
os.makedirs(CACHE_DIR, exist_ok=True)

def cache_key(ticker: str, start: str, end: str) -> str:
    return hashlib.md5(f'{ticker}_{start}_{end}'.encode()).hexdigest()

def get_cached(ticker: str, start: str, end: str):
    key = cache_key(ticker, start, end)
    path = os.path.join(CACHE_DIR, f'{key}.json')
    if os.path.exists(path):
        with open(path) as f:
            return json.load(f)
    return None

def set_cached(ticker: str, start: str, end: str, data):
    key = cache_key(ticker, start, end)
    path = os.path.join(CACHE_DIR, f'{key}.json')
    with open(path, 'w') as f:
        json.dump(data, f)

if __name__ == '__main__':
    set_cached('AAPL', '2024-01-01', '2024-01-31', {'close': [150, 151, 149]})
    cached = get_cached('AAPL', '2024-01-01', '2024-01-31')
    print('Cached data for AAPL:', cached)
    print('Cache miss for MSFT:', get_cached('MSFT', '2024-01-01', '2024-01-31'))

Gestire gli orari di contrattazione e le lacune di mercato

I mercati sono chiusi nei fine settimana e nei giorni festivi. Gli intervalli di date che includono giorni non lavorativi presentano lacune nei dati. Rilevi e gestisca sempre queste lacune, invece di presupporre che i dati giornalieri siano continui.

import pandas as pd
from pandas.tseries.offsets import BDay

def detect_gaps(history: pd.DataFrame) -> list[str]:
    if history.empty:
        return []
    date_range = pd.date_range(
        start=history.index.min(),
        end=history.index.max(),
        freq=BDay()  # Business days only
    )
    missing = date_range.difference(history.index)
    return [str(d.date()) for d in missing]

import yfinance as yf
history = yf.Ticker('AAPL').history(start='2024-12-23', end='2025-01-07')
gaps = detect_gaps(history)
print('Missing business days (holidays):', gaps)

Creare uno strumento per i dati di mercato destinato agli agenti

Registri un recuperatore di dati di mercato come strumento dell'agente. L'LLM può chiamarlo per recuperare i dati e utilizzare poi un altro strumento (di analisi) per elaborarli.

import yfinance as yf, json

def get_market_data_tool(ticker: str, period: str = '1y') -> str:
    cached = get_cached(ticker, period, 'yfinance')
    if cached:
        return json.dumps(cached)
    try:
        hist = yf.Ticker(ticker).history(period=period)
        if hist.empty:
            return json.dumps({'error': f'No data for {ticker}'})
        result = {
            'ticker':     ticker,
            'period':     period,
            'start':      str(hist.index.min().date()),
            'end':        str(hist.index.max().date()),
            'latest_close': float(hist['Close'].iloc[-1]),
            'pct_change_ytd': float((hist['Close'].iloc[-1] / hist['Close'].iloc[0] - 1) * 100),
            'rows':       len(hist)
        }
        set_cached(ticker, period, 'yfinance', result)
        return json.dumps(result)
    except Exception as e:
        return json.dumps({'error': str(e)})

Dati fondamentali da yfinance

Oltre ai dati sui prezzi, yfinance fornisce dati fondamentali: rapporto P/E, utile per azione, capitalizzazione di mercato e altro ancora. I dati fondamentali arricchiscono l'analisi dell'agente, andando oltre la semplice dinamica dei prezzi.

import yfinance as yf

ticker = yf.Ticker('AAPL')
info  = ticker.info

print('Market Cap:      ', info.get('marketCap'))
print('P/E Ratio:       ', info.get('trailingPE'))
print('EPS:             ', info.get('trailingEps'))
print('52-Week High:    ', info.get('fiftyTwoWeekHigh'))
print('52-Week Low:     ', info.get('fiftyTwoWeekLow'))
print('Dividend Yield:  ', info.get('dividendYield'))
print('Analyst Target:  ', info.get('targetMeanPrice'))

Gestione degli errori: ticker revocati e non validi

Non tutti i simboli ticker sono validi o attualmente negoziati. Per una società non più quotata, la cronologia restituita è vuota. Convalidi sempre la risposta prima di procedere con l'analisi.

import yfinance as yf

def safe_fetch(ticker_symbol: str, period: str = '1y') -> dict:
    try:
        ticker = yf.Ticker(ticker_symbol)
        history = ticker.history(period=period)

        if history.empty:
            return {
                'error': f'No data for {ticker_symbol}. May be delisted or invalid.',
                'ticker': ticker_symbol
            }
        return {
            'ticker':       ticker_symbol,
            'latest_close': float(history['Close'].iloc[-1]),
            'data_start':   str(history.index.min().date()),
            'bars':         len(history)
        }
    except Exception as e:
        return {'error': str(e), 'ticker': ticker_symbol}

print(safe_fetch('AAPL'))    # valid
print(safe_fetch('INVALID')) # returns error dict

Che cosa restituisce l'outputsize «compact» nell'endpoint TIME_SERIES_DAILY di Alpha Vantage?

Comprendere i parametri relativi alla dimensione dell'output delle API è importante per gestire la larghezza di banda, la latenza e le quote API negli agenti finanziari.

Riepilogo dell'integrazione delle API per i dati di mercato

Utilizzi yfinance per la prototipazione rapida (gratuito), Polygon.io per la produzione (affidabile, a pagamento) e Alpha Vantage come opzione con piano gratuito. Implementi sempre la limitazione della frequenza, la cache su disco per i dati storici e il rilevamento delle lacune relative ai giorni non lavorativi.

Renda il recupero disponibile come strumento dell'agente, in modo che l'LLM possa richiedere i dati quando necessario.

Domande Frequenti

La lezione «Integrazione delle API per i dati di mercato» è gratuita?

Sì — il testo completo di «Integrazione delle API per i dati di mercato» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Agents, passa a CoddyKit PRO. Il corso AI Agents include 4 lezioni in totale.

Cosa imparerò in «Integrazione delle API per i dati di mercato»?

Alpha Vantage, Yahoo Finance e Polygon.io per dati in tempo reale e storici. Eserciti AI Agents con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Agents?

Non è richiesta alcuna esperienza precedente. AI Agents su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Integrazione delle API per i dati di mercato»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Agents?

Sì. Ogni lezione AI Agents include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Integrazione delle API per i dati di mercato
  2. Strumenti dell’agente per l’analisi dei portafogli
  3. Limiti di sicurezza per rischio e conformità
  4. Backtesting delle decisioni dell’agente
← Torna a AI Agents