0Pricing
AI Agents · Lekcja

Integracja z interfejsami API danych rynkowych

Alpha Vantage, Yahoo Finance i Polygon.io do pobierania danych bieżących i historycznych.

Integracja z interfejsami API danych rynkowych to bezpłatna lekcja AI Agents na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Agents, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Agents zawiera 4 lekcji w sumie.

Dane rynkowe w agentach finansowych

Agenty do analizy finansowej potrzebują dostępu do bieżących i historycznych danych rynkowych. Typowe rodzaje danych obejmują OHLCV (Open/High/Low/Close/Volume), daty publikacji wyników, wskaźniki fundamentalne oraz łańcuchy opcji.

Takie dane udostępnia kilka interfejsów API: yfinance (bezpłatny, Yahoo Finance), Polygon.io (płatny, niezawodny) oraz Alpha Vantage (dostępny bezpłatny plan).

yfinance: historyczne dane cenowe

yfinance opakowuje API Yahoo Finance i jest najszybszym sposobem na rozpoczęcie pracy. Ticker.history() zwraca obiekt pandas DataFrame zawierający dane 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: niestandardowe zakresy dat

Parametrów start i end należy używać do określania niestandardowych zakresów dat, a parametru interval do danych śróddziennych (1m, 5m, 1h). Należy pamiętać, że dane śróddzienne są ograniczone do ostatnich 60 dni, zależnie od interwału.

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())

Interfejs REST API Polygon.io

Polygon.io udostępnia profesjonalnej jakości dane rynkowe, z wyższymi limitami zapytań i bardziej niezawodnym czasem działania niż bezpłatne źródła. Należy używać go w agentach finansowych działających produkcyjnie.

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'])

Alpha Vantage TIME_SERIES_DAILY

Alpha Vantage udostępnia bezpłatny plan (25 wywołań dziennie) oraz plan płatny. Endpoint TIME_SERIES_DAILY zwraca dane OHLCV z opcjonalnie skorygowanymi cenami.

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, ...}}

Limity zapytań i logika ponawiania

Wszystkie interfejsy API danych rynkowych nakładają limity zapytań. Ich przekroczenie powoduje błąd 429 (Too Many Requests). Należy zawsze implementować wykładnicze zwiększanie odstępów między próbami i przestrzegać limitów.

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)

Buforowanie danych rynkowych

Dane historyczne są niezmienne — wczorajsza cena zamknięcia nigdy się nie zmienia. Należy je buforować, aby uniknąć zbędnych wywołań API. Można użyć prostego bufora na dysku, którego kluczem jest (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'))

Obsługa godzin handlu i luk rynkowych

Rynki są zamknięte w weekendy i święta. Zakresy dat obejmujące dni, w których nie odbywa się handel, będą zawierać luki w danych. Należy zawsze wykrywać te luki i odpowiednio je obsługiwać, zamiast zakładać ciągłość danych dziennych.

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)

Tworzenie narzędzia danych rynkowych dla agentów

Należy zarejestrować moduł pobierający dane rynkowe jako narzędzie agenta. LLM może wywołać je w celu pobrania danych, a następnie użyć innego narzędzia (analitycznego) do przetworzenia wyniku.

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)})

Dane fundamentalne z yfinance

Oprócz danych cenowych yfinance udostępnia dane fundamentalne: wskaźnik P/E, zysk na akcję, kapitalizację rynkową i inne. Dane fundamentalne wzbogacają analizę agenta o informacje wykraczające poza same zmiany cen.

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'))

Obsługa błędów: wycofane z obrotu i nieprawidłowe tickery

Nie wszystkie symbole tickerów są prawidłowe lub są obecnie przedmiotem obrotu. Dla spółki wycofanej z obrotu zostanie zwrócona pusta historia. Przed przystąpieniem do analizy należy zawsze zweryfikować odpowiedź.

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

Co zwraca parametr outputsize „compact” w endpoincie Alpha Vantage TIME_SERIES_DAILY?

Zrozumienie parametrów określających rozmiar odpowiedzi API jest ważne dla zarządzania przepustowością, opóźnieniami i limitami API w agentach finansowych.

Podsumowanie integracji z API danych rynkowych

Należy używać yfinance do szybkiego prototypowania (bezpłatny), Polygon.io w środowisku produkcyjnym (niezawodny, płatny), a Alpha Vantage jako opcji z bezpłatnym planem. Należy zawsze implementować ograniczanie liczby zapytań, buforowanie na dysku danych historycznych oraz wykrywanie luk dotyczących dni, w których nie odbywa się handel.

Pobieranie danych należy udostępnić jako narzędzie agenta, aby LLM mógł żądać danych, gdy są potrzebne.

Często zadawane pytania

Czy lekcja „Integracja z interfejsami API danych rynkowych” jest bezpłatna?

Tak — pełny tekst „Integracja z interfejsami API danych rynkowych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Agents, przejdź na CoddyKit PRO. Kurs AI Agents zawiera 4 lekcji w sumie.

Co nauczysz się w „Integracja z interfejsami API danych rynkowych”?

Alpha Vantage, Yahoo Finance i Polygon.io do pobierania danych bieżących i historycznych. Ćwiczysz AI Agents z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Agents?

Nie wymagamy żadnego doświadczenia. AI Agents w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Integracja z interfejsami API danych rynkowych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Agents?

Tak. Każda lekcja AI Agents zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Integracja z interfejsami API danych rynkowych
  2. Narzędzia agenta do analizy portfela
  3. Mechanizmy ochronne dotyczące ryzyka i zgodności
  4. Testowanie wsteczne decyzji agenta
← Powrót do AI Agents