{quote.shortName}
R$ {quote.regularMarketPrice.toFixed(2)}
0 ? 'text-green-600' : 'text-red-600'}> {quote.regularMarketChangePercent.toFixed(2)}%
Erro ao carregar cotação
;
if (isLoading) return Carregando...
;
const quote = data.results[0];
return (
{quote.symbol}
R$ {quote.regularMarketPrice.toFixed(2)}
SDK oficial para Python 3.8+ com suporte síncrono e assíncrono.
#### Instalação
```bash
pip install brapi
# Com suporte a aiohttp (opcional, melhor performance)
pip install brapi[aiohttp]
```
#### Exemplo Rápido (Síncrono)
```python
from brapi import Brapi
client = Brapi(api_key="seu_token")
quote = client.quote.retrieve(tickers="PETR4")
print(quote.results[0].regular_market_price)
```
#### Exemplo Rápido (Assíncrono)
```python
import asyncio
from brapi import AsyncBrapi
async def main():
async with AsyncBrapi(api_key="seu_token") as client:
quote = await client.quote.retrieve(tickers="PETR4")
print(quote.results[0].regular_market_price)
asyncio.run(main())
```
#### Características
* ✅ Type hints completos
* ✅ Cliente síncrono e assíncrono
* ✅ Powered by httpx (HTTP/2)
* ✅ Integração Flask, FastAPI, Pandas
* ✅ Context managers
**Links:**
* 📚 [Documentação completa](/docs/sdks/python)
* 📦 [PyPI Package](https://pypi.org/project/brapi/)
* 🔧 [GitHub Repository](https://github.com/brapi-dev/brapi-python)
***
## Comparação de Features
| Feature | TypeScript/JS | Python |
| ---------------- | ------------- | ------------ |
| Tipos completos | ✅ TypeScript | ✅ Type hints |
| Autocomplete IDE | ✅ | ✅ |
| Sync/Async | ✅ Async | ✅ Ambos |
| Retry automático | ✅ | ✅ |
| Erros tipados | ✅ | ✅ |
| HTTP/2 | ✅ | ✅ |
| Bundle size | 📦 Pequeno | N/A |
| Python 3.8+ | N/A | ✅ |
| Node.js/Browser | ✅ | N/A |
***
## Casos de Uso
### 1. Aplicações Web
**Next.js / React:**
```typescript
import Brapi from 'brapi';
// Server Component
const client = new Brapi({ apiKey: process.env.BRAPI_API_KEY });
const quote = await client.quote.retrieve('PETR4');
```
**FastAPI / Flask:**
```python
from fastapi import FastAPI
from brapi import AsyncBrapi
app = FastAPI()
client = AsyncBrapi(api_key="seu_token")
@app.get("/quote/{ticker}")
async def get_quote(ticker: str):
quote = await client.quote.retrieve(tickers=ticker)
return quote.results[0]
```
### 2. Análise de Dados
**Python com Pandas:**
```python
import pandas as pd
from brapi import Brapi
client = Brapi(api_key="seu_token")
# Buscar múltiplas cotações
tickers = "PETR4,VALE3,ITUB4"
quote = client.quote.retrieve(tickers=tickers)
# Converter para DataFrame
df = pd.DataFrame([
{
'symbol': r.symbol,
'price': r.regular_market_price,
'change': r.regular_market_change_percent
}
for r in quote.results
])
print(df)
```
### 3. Scripts e Automação
**Monitoramento de Preços:**
```python
from brapi import Brapi
import time
client = Brapi(api_key="seu_token")
while True:
quote = client.quote.retrieve(tickers="PETR4")
price = quote.results[0].regular_market_price
print(f"PETR4: R$ {price:.2f}")
time.sleep(60) # Atualiza a cada minuto
```
### 4. APIs e Microsserviços
**Express.js API:**
```typescript
import express from 'express';
import Brapi from 'brapi';
const app = express();
const client = new Brapi({ apiKey: process.env.BRAPI_API_KEY });
app.get('/api/quote/:ticker', async (req, res) => {
try {
const quote = await client.quote.retrieve(req.params.ticker);
res.json(quote);
} catch (error) {
res.status(500).json({ error: error.message });
}
});
app.listen(3000);
```
### 5. Dashboards e Visualizações
**TypeScript com Chart.js:**
```typescript
const client = new Brapi({ apiKey: process.env.BRAPI_API_KEY });
async function updateChart() {
const quote = await client.quote.retrieve('PETR4,VALE3,ITUB4');
const labels = quote.results.map(r => r.symbol);
const prices = quote.results.map(r => r.regularMarketPrice);
// Atualizar gráfico com os dados
chart.data.labels = labels;
chart.data.datasets[0].data = prices;
chart.update();
}
```
***
## Recursos Suportados
Ambas as SDKs suportam todos os endpoints da API:
### Mercado Brasileiro (B3)
* ✅ **Cotações** - Ações, ETFs, FIIs, BDRs
* ✅ **Dados fundamentalistas** - Balanços, DRE, indicadores
* ✅ **Dividendos** - Histórico de proventos
* ✅ **Histórico** - Preços históricos
### Criptomoedas
* ✅ **Bitcoin, Ethereum, etc.**
* ✅ **Lista de moedas disponíveis**
### Indicadores Econômicos
* ✅ **Inflação** - IPCA, IGP-M, etc.
* ✅ **Taxa de juros** - SELIC, CDI
* ✅ **Câmbio** - USD, EUR, etc.
***
## Tratamento de Erros
Ambas as SDKs lançam exceções específicas por tipo de erro:
### TypeScript
```typescript
import Brapi from 'brapi';
try {
const quote = await client.quote.retrieve('INVALID');
} catch (error) {
if (error instanceof Brapi.NotFoundError) {
console.log('Ticker não encontrado');
} else if (error instanceof Brapi.RateLimitError) {
console.log('Limite de requisições atingido');
} else if (error instanceof Brapi.AuthenticationError) {
console.log('Token inválido');
}
}
```
### Python
```python
from brapi import Brapi, NotFoundError, RateLimitError
try:
quote = client.quote.retrieve(tickers="INVALID")
except NotFoundError:
print("Ticker não encontrado")
except RateLimitError:
print("Limite de requisições atingido")
```
***
## Configuração Avançada
### Retry Automático
```typescript
// TypeScript
const client = new Brapi({
apiKey: process.env.BRAPI_API_KEY,
maxRetries: 3, // Tenta até 3 vezes
});
```
```python
# Python
client = Brapi(
api_key="seu_token",
max_retries=3, # Tenta até 3 vezes
)
```
### Timeouts
```typescript
// TypeScript
const client = new Brapi({
apiKey: process.env.BRAPI_API_KEY,
timeout: 10000, // 10 segundos
});
```
```python
# Python
client = Brapi(
api_key="seu_token",
timeout=10.0, # 10 segundos
)
```
***
## Gerado com Stainless
Nossas SDKs são geradas automaticamente usando [Stainless](https://www.stainless.com/), garantindo:
* ✅ Sempre sincronizadas com a API
* ✅ Tipos precisos e atualizados
* ✅ Documentação inline
* ✅ Padrões de indústria
* ✅ Testes automáticos
***
## Começar a Usar
Escolha a SDK da sua linguagem:
### TypeScript / JavaScript
```bash
npm install brapi
```
**[📚 Ver Documentação Completa →](/docs/sdks/typescript)**
**Links:**
* 📦 [NPM Package](https://www.npmjs.com/package/brapi)
* 🔧 [GitHub Repository](https://github.com/brapi-dev/brapi-typescript)
***
### Python
```bash
pip install brapi
```
**[📚 Ver Documentação Completa →](/docs/sdks/python)**
**Links:**
* 📦 [PyPI Package](https://pypi.org/project/brapi/)
* 🔧 [GitHub Repository](https://github.com/brapi-dev/brapi-python)
***
## Futuras SDKs
Estamos trabalhando em SDKs para:
* 🔜 **Go** - Em desenvolvimento
* 🔜 **PHP** - Planejado
* 🔜 **Java** - Planejado
* 🔜 **Ruby** - Planejado
Interessado em contribuir ou sugerir uma SDK? [Abra uma issue](https://github.com/brapi-dev) no GitHub!
***
## Suporte e Comunidade
* 💬 [GitHub Discussions](https://github.com/brapi-dev)
* 🐛 [Reportar Bug](https://github.com/brapi-dev)
* 📧 [Email de Suporte](mailto:contato@brapi.dev)
* 📚 [Documentação da API](/docs)
***
## Open Source
Todas as nossas SDKs são **open source** e licenciadas sob MIT. Contribuições são muito bem-vindas!
* ⭐ [Star no GitHub](https://github.com/brapi-dev)
* 🤝 [Contribuir](https://github.com/brapi-dev)
* 📖 [Changelog](https://github.com/brapi-dev)
# SDK Python
URL: /docs/sdks/python.mdx
SDK oficial Python da brapi.dev. Biblioteca completa com type hints, suporte síncrono e assíncrono, integração com asyncio e aiohttp, tratamento de erros automático.
***
title: 'SDK Python'
description: >-
SDK oficial Python da brapi.dev. Biblioteca completa com type hints, suporte
síncrono e assíncrono, integração com asyncio e aiohttp, tratamento de erros
automático.
full: false
keywords:
brapi, sdk, python, pip, api client, asyncio, httpx
openGraph:
title: SDK Python - brapi.dev
description: >-
SDK oficial Python com type hints e suporte síncrono e assíncrono
type: website
locale: pt\_BR
lastUpdated: '2025-10-12T20:00:00.000Z'
lang: pt-BR
howToSteps:
* name: 'Instale a SDK via pip'
text: 'Execute pip install brapi no terminal. Para melhor performance async, use pip install brapi\[aiohttp].'
* name: 'Configure a variável de ambiente com seu token'
text: 'Crie um arquivo .env com BRAPI\_API\_KEY=seu\_token\_aqui e use python-dotenv para carregar: from dotenv import load\_dotenv; load\_dotenv().'
* name: 'Importe e inicialize o cliente Brapi'
text: 'No seu código Python, importe com from brapi import Brapi e crie uma instância: client = Brapi(api\_key=os.environ.get("BRAPI\_API\_KEY")).'
* name: 'Busque cotações com o cliente síncrono ou assíncrono'
text: 'Use quote = client.quote.retrieve(tickers="PETR4") para síncrono, ou await client.quote.retrieve(tickers="PETR4") com AsyncBrapi para async.'
* name: 'Trate erros usando as exceções tipadas'
text: 'Importe exceções como NotFoundError, RateLimitError e use try/except para tratamento específico de cada tipo de erro.'
howToTools:
* 'Python 3.8+'
* 'pip'
* 'Editor de código'
howToSupplies:
* 'Conta brapi.dev'
* 'Token de API brapi.dev'
* 'Ambiente Python configurado'
***
SDK oficial da brapi.dev para Python 3.8+, oferecendo acesso conveniente à API REST com type hints completos e suporte síncrono e assíncrono.
## Características
* ✅ **Type hints completos** - Autocomplete e validação no IDE
* ✅ **Python 3.8+** - Compatível com versões modernas
* ✅ **Sync e Async** - Cliente síncrono e assíncrono
* ✅ **Powered by httpx** - HTTP/2 e connection pooling
* ✅ **Suporte aiohttp** - Performance assíncrona otimizada
* ✅ **Tratamento de erros** - Exceções tipadas e descritivas
* ✅ **Retry automático** - Tratamento inteligente de falhas
* ✅ **Gerado com Stainless** - Sempre atualizado com a API
## Instalação
```bash
pip install brapi
```
Com suporte a aiohttp (opcional, para melhor performance async):
```bash
pip install brapi[aiohttp]
```
## Início Rápido
### Cliente Síncrono
```python
import os
from brapi import Brapi
client = Brapi(
api_key=os.environ.get("BRAPI_API_KEY"),
)
# Buscar cotação
quote = client.quote.retrieve(tickers="PETR4")
print(quote.results[0].regular_market_price)
# Múltiplas ações
quotes = client.quote.retrieve(tickers="PETR4,VALE3,ITUB4")
for stock in quotes.results:
print(f"{stock.symbol}: R$ {stock.regular_market_price}")
```
### Cliente Assíncrono
```python
import os
import asyncio
from brapi import AsyncBrapi
client = AsyncBrapi(
api_key=os.environ.get("BRAPI_API_KEY"),
)
async def main():
quote = await client.quote.retrieve(tickers="PETR4")
print(quote.results[0].regular_market_price)
asyncio.run(main())
```
## Configuração
### Variáveis de Ambiente
Recomendamos usar `python-dotenv` para gerenciar variáveis de ambiente:
```bash
pip install python-dotenv
```
Crie um arquivo `.env`:
```bash
BRAPI_API_KEY=seu_token_aqui
```
No seu código:
```python
import os
from dotenv import load_dotenv
from brapi import Brapi
load_dotenv()
client = Brapi(
api_key=os.environ.get("BRAPI_API_KEY"),
)
```
### Opções do Cliente
```python
client = Brapi(
api_key="seu_token",
environment="production", # 'production' ou 'sandbox'
max_retries=2, # Número de tentativas (padrão: 2)
timeout=60.0, # Timeout em segundos (padrão: 60)
)
```
## Exemplos de Uso
### Cotações
```python
# Cotação única
quote = client.quote.retrieve(tickers="PETR4")
stock = quote.results[0]
print(f"Símbolo: {stock.symbol}")
print(f"Nome: {stock.short_name}")
print(f"Preço: R$ {stock.regular_market_price}")
print(f"Variação: {stock.regular_market_change_percent}%")
# Com módulos adicionais
quote_with_data = client.quote.retrieve(
tickers="PETR4",
modules="summaryProfile,balanceSheetHistory"
)
```
### Lista de Ações
```python
# Todas as ações disponíveis
stocks = client.quote.list()
for stock in stocks.stocks:
print(f"{stock.stock}: {stock.name} ({stock.type})")
# Com paginação
stocks_page = client.quote.list(page=1, limit=50)
```
### Criptomoedas
```python
# Cotação de cripto
crypto = client.crypto.retrieve(coin="BTC")
print(f"Bitcoin: ${crypto.currency}")
# Lista de criptos disponíveis
cryptos = client.crypto.available()
for coin in cryptos.coins:
print(f"{coin.coin}: {coin.name}")
```
### Moedas
```python
# Cotação de moeda
currency = client.currency.retrieve(currency="USD-BRL")
print(f"Dólar: R$ {currency.ask}")
# Lista de moedas disponíveis
currencies = client.currency.available()
```
### Inflação
```python
# Dados de inflação do Brasil
inflation = client.inflation.retrieve(country="brazil")
print(f"IPCA: {inflation.IPCA}")
# Países disponíveis
countries = client.inflation.available()
```
### Taxa de Juros
```python
# Taxa SELIC
selic = client.prime_rate.retrieve(country="brazil")
print(f"SELIC: {selic.value}%")
# Países disponíveis
countries = client.prime_rate.available()
```
## Cliente Assíncrono
### Com httpx (padrão)
```python
import asyncio
from brapi import AsyncBrapi
async def main():
client = AsyncBrapi(api_key="seu_token")
# Todas as operações usam await
quote = await client.quote.retrieve(tickers="PETR4")
print(quote.results[0].regular_market_price)
# Não esqueça de fechar o cliente
await client.close()
asyncio.run(main())
```
### Com Context Manager
```python
import asyncio
from brapi import AsyncBrapi
async def main():
async with AsyncBrapi(api_key="seu_token") as client:
quote = await client.quote.retrieve(tickers="PETR4")
print(quote.results[0].regular_market_price)
# Cliente fechado automaticamente
asyncio.run(main())
```
### Com aiohttp (melhor performance)
```python
import asyncio
from brapi import AsyncBrapi, DefaultAioHttpClient
async def main():
async with AsyncBrapi(
api_key="seu_token",
http_client=DefaultAioHttpClient(),
) as client:
quote = await client.quote.retrieve(tickers="PETR4")
print(quote.results[0].regular_market_price)
asyncio.run(main())
```
### Requisições Concorrentes
```python
import asyncio
from brapi import AsyncBrapi
async def get_multiple_quotes():
async with AsyncBrapi(api_key="seu_token") as client:
# Buscar várias cotações em paralelo
tasks = [
client.quote.retrieve(tickers="PETR4"),
client.quote.retrieve(tickers="VALE3"),
client.quote.retrieve(tickers="ITUB4"),
]
results = await asyncio.gather(*tasks)
for quote in results:
stock = quote.results[0]
print(f"{stock.symbol}: R$ {stock.regular_market_price}")
asyncio.run(get_multiple_quotes())
```
## Tratamento de Erros
```python
from brapi import Brapi
from brapi import (
APIError,
BadRequestError,
AuthenticationError,
NotFoundError,
RateLimitError,
)
client = Brapi(api_key="seu_token")
try:
quote = client.quote.retrieve(tickers="INVALID")
except NotFoundError as e:
print(f"Ticker não encontrado: {e}")
except RateLimitError as e:
print(f"Limite de requisições: {e}")
except AuthenticationError as e:
print(f"Token inválido: {e}")
except APIError as e:
print(f"Erro na API: {e}")
```
### Tipos de Exceção
| Exception | Status | Descrição |
| -------------------------- | ------ | ---------------------- |
| `BadRequestError` | 400 | Requisição inválida |
| `AuthenticationError` | 401 | Token inválido |
| `PermissionDeniedError` | 403 | Sem permissão |
| `NotFoundError` | 404 | Recurso não encontrado |
| `UnprocessableEntityError` | 422 | Dados inválidos |
| `RateLimitError` | 429 | Limite de requisições |
| `InternalServerError` | 5xx | Erro no servidor |
| `APIConnectionError` | N/A | Erro de conexão |
## Integração com Flask
```python
from flask import Flask, jsonify
from brapi import Brapi
app = Flask(__name__)
client = Brapi(api_key="seu_token")
@app.route('/api/quote/