Documentação

Technical Indicators

client.indicators provides technical indicators on top of client.marketdata. It uses TA-Lib automatically when installed and falls back to native SDK implementations for common indicators and book metrics.

Install with TA-Lib support:

pip install "investflex-py[indicators-talib]"

The base SDK still works without TA-Lib.

Snapshot examples

from investflex import AsyncInvestflexClient

async with AsyncInvestflexClient.from_env() as client:
    rsi = await client.indicators.rsi("PETR4", period=14, source="1m")
    print(rsi.value, rsi.ready, rsi.engine)

import { InvestflexClient } from "@investflex/sdk";

const client = InvestflexClient.fromEnv();

const rsi = await client.indicators.rsi("PETR4", { period: 14, source: "1m" });
console.log(rsi.value, rsi.ready, rsi.engine);

async with AsyncInvestflexClient.from_env() as client:
    macd = await client.indicators.macd("PETR4", source="1m")
    print(macd.value["macd"], macd.value["signal"], macd.value["histogram"])

const macd = await client.indicators.macd("PETR4", { source: "1m" });
const parts = macd.value as {
  macd: number | null;
  signal: number | null;
  histogram: number | null;
};
console.log(parts.macd, parts.signal, parts.histogram);

async with AsyncInvestflexClient.from_env() as client:
    imbalance = await client.indicators.book_imbalance("PETR4", levels=3)
    print(imbalance.value)

const imbalance = await client.indicators.bookImbalance("PETR4", { levels: 3 });
console.log(imbalance.value);

Sources

Source	Backing data
`"trades"`	`client.marketdata.trades(...)`
`"book"`	`client.marketdata.last_book(...)`
`"1m"`, `"5m"`, `"15m"`, `"1h"`, `"D"`	`client.marketdata.candles(...)`
`"session"`	Trade history, for accumulators such as VWAP

Helpers

sma(symbol, period=20, source="1m")
ema(symbol, period=20, source="1m")
rsi(symbol, period=14, source="1m")
macd(symbol, fast=12, slow=26, signal=9, source="1m")
bbands(symbol, period=20, stddev=2.0, source="1m")
atr(symbol, period=14, source="1m")
vwap(symbol, source="trades")
spread(symbol)
microprice(symbol)
book_imbalance(symbol, levels=3)

Every helper returns an IndicatorValue:

class IndicatorValue:
    symbol: str
    indicator: str
    value: float | dict[str, float | None] | None
    ready: bool
    warmup_remaining: int
    source: str
    engine: str
    timestamp: datetime

interface IndicatorValue {
  symbol: string;
  indicator: string;
  value: number | Record<string, number | null> | null;
  ready: boolean;
  warmupRemaining: number;
  source: string;
  engine: string;
  timestamp: Date;
}

Use ready before triggering execution. A value may be unavailable while the indicator is warming up.

Candles

The SDK exposes the Investflex candle service through client.marketdata.candles(...):

async with AsyncInvestflexClient.from_env() as client:
    candles = await client.marketdata.candles(
        "WINFUT",
        timeframe="15m",
        start="2026-01-16 20:10:11",
        end="2026-02-04 20:10:11",
        limit=200,
    )
    print(candles[-1].close)

const candles = await client.marketdata.candles("WINFUT", {
  timeframe: "15m",
  start: "2026-01-16 20:10:11",
  end: "2026-02-04 20:10:11",
  limit: 200,
});
console.log(candles.at(-1)?.close);

For live candles:

from investflex.models.marketdata import Candle
from investflex.services.marketdata import MarketDataService

async with AsyncInvestflexClient.from_env() as client:
    async with client.marketdata.stream() as stream:
        await stream.subscribe_candles("WINV24", timeframe="15m")
        async for evt in MarketDataService.parse(stream):
            if isinstance(evt, Candle):
                print(evt.symbol, evt.timeframe, evt.close)

import { MarketDataService, type Candle } from "@investflex/sdk";

const stream = await client.marketdata.stream().open();
await stream.subscribeCandles("WINV24", { timeframe: "15m" });
for await (const evt of MarketDataService.parse(stream)) {
  const candle = evt as Partial<Candle>;
  if (candle.timeframe) console.log(candle.symbol, candle.timeframe, candle.close);
}
await stream.close();