0Pricing
AI Agents · Aula

Integração com APIs de dados de mercado

Alpha Vantage, Yahoo Finance e Polygon.io para dados em tempo real e históricos.

Integração com APIs de dados de mercado é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.

Dados de mercado em agentes financeiros

Agentes de análise financeira precisam de acesso a dados de mercado em tempo real e históricos. Entre os tipos comuns de dados estão OHLCV (Abertura/Máxima/Mínima/Fechamento/Volume), datas de divulgação de resultados, índices fundamentalistas e cadeias de opções.

Várias APIs fornecem esses dados: yfinance (gratuita, do Yahoo Finance), Polygon.io (paga e confiável) e Alpha Vantage (com plano gratuito disponível).

yfinance: dados históricos de preços

yfinance encapsula a API do Yahoo Finance e é a maneira mais rápida de começar. Ticker.history() retorna um DataFrame do pandas com dados 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: intervalos de datas personalizados

Utilize os parâmetros start e end para definir intervalos de datas personalizados ou interval para dados intradiários (1m, 5m, 1h). Observe que os dados intradiários são limitados aos últimos 60 dias, dependendo do intervalo.

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 do Polygon.io

Polygon.io fornece dados de mercado de nível profissional, com limites de requisições mais altos e disponibilidade mais confiável do que as fontes gratuitas. Utilize-o em agentes financeiros destinados à produção.

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 do Alpha Vantage

Alpha Vantage oferece um plano gratuito (25 chamadas por dia) e um plano pago. O endpoint TIME_SERIES_DAILY retorna dados OHLCV com preços ajustados opcionais.

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

Limites de requisições e lógica de novas tentativas

Todas as APIs de dados de mercado impõem limites de requisições. Se você os exceder, receberá 429 (Muitas solicitações). Implemente sempre um recuo exponencial e respeite os limites.

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)

Armazenamento em cache de dados de mercado

Os dados históricos são imutáveis — o preço de fechamento de ontem nunca muda. Armazene-os em cache para evitar chamadas redundantes à API. Utilize um cache simples em disco indexado por (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'))

Tratamento dos horários de negociação e das lacunas do mercado

Os mercados permanecem fechados nos fins de semana e feriados. Intervalos de datas que abrangem dias sem negociação terão lacunas nos dados. Detecte e trate sempre essas lacunas, em vez de presumir que os dados diários são contínuos.

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)

Criação de uma ferramenta de dados de mercado para agentes

Registre um mecanismo de obtenção de dados de mercado como uma ferramenta do agente. O LLM pode chamá-la para recuperar dados e, em seguida, utilizar outra ferramenta (análise) para processar o resultado.

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

Dados fundamentalistas do yfinance

Além dos dados de preços, o yfinance fornece dados fundamentalistas: índice P/L, lucro por ação, capitalização de mercado e muito mais. Os dados fundamentalistas enriquecem a análise do agente para além da simples movimentação dos preços.

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

Tratamento de erros: Ticker removidos e inválidos

Nem todos os símbolos de Ticker são válidos ou estão sendo negociados atualmente. Uma empresa removida da bolsa retorna um histórico vazio. Valide sempre a resposta antes de prosseguir com a análise.

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

O que o tamanho da saída «compact» retorna no endpoint TIME_SERIES_DAILY do Alpha Vantage?

Compreender os parâmetros de tamanho da saída da API é importante para gerenciar a largura de banda, a latência e as cotas de API em agentes financeiros.

Recapitulação da integração com APIs de dados de mercado

Utilize yfinance para prototipagem rápida (gratuito), Polygon.io para produção (confiável e pago) e Alpha Vantage como opção com plano gratuito. Implemente sempre limitação de requisições, armazenamento em cache no disco para dados históricos e detecção de lacunas em dias sem negociação.

Disponibilize a obtenção de dados como uma ferramenta do agente para que o LLM possa solicitá-los quando necessário.

Perguntas Frequentes

A aula “Integração com APIs de dados de mercado” é grátis?

Sim — o texto completo de “Integração com APIs de dados de mercado” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.

O que vou aprender em “Integração com APIs de dados de mercado”?

Alpha Vantage, Yahoo Finance e Polygon.io para dados em tempo real e históricos. Você pratica AI Agents com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Agents?

Nenhuma experiência prévia é necessária. AI Agents no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Integração com APIs de dados de mercado”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Agents?

Sim. Cada aula de AI Agents inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Integração com APIs de dados de mercado
  2. Ferramentas de agentes para análise de portfólios
  3. Barreiras de proteção para riscos e conformidade
  4. Backtesting das decisões dos agentes
← Voltar para AI Agents