Free RSI API: Data, Limits & Python

TL;DR

Free RSI API response fields and parameters

An RSI indicator API returns a momentum oscillator, normally on a 0–100 scale, derived from average gains and losses over a lookback period. Fourteen periods is common, but interval, price series, smoothing, precision, and warm-up behavior differ. Treat each provider’s documentation as authoritative.

How to compare free technical indicator APIs

Free RSI API options versus calculating RSI locally

A documented RSI endpoint is convenient, but it is not automatically the cheapest or most reproducible choice. If the application already retrieves completed OHLCV bars, calculating RSI locally avoids an extra request per symbol and gives full control over smoothing, seeding, and revisions. A provider endpoint is more attractive when you need only a few values, want one normalized response across asset classes, or do not want to maintain indicator code.

Use a numerical fixture to prove two RSI implementations agree

Save at least 40 completed closes containing a flat segment, a one-direction run, a gap, and one adjusted-price event. Request a 14-period close-based RSI from the provider, then recalculate the same timestamps locally. Compare the first non-null timestamp, seed window, rounding, and every later value within a documented tolerance. If disagreement begins only after a corporate action or session gap, investigate the price series and adjustment rules before blaming the formula.

RSI API for Python: a safe integration path

Use a small local implementation as a numerical fixture for the provider response. The function below applies Wilder’s recursive smoothing, preserves the warm-up rows as None, and defines the flat, all-gain, and all-loss boundaries explicitly.

def wilder_rsi(closes: list[float], period: int = 14) -> list[float | None]:
    if period < 2:
        raise ValueError("period must be at least 2")
    if any(value is None or value <= 0 for value in closes):
        raise ValueError("closes must contain positive completed-bar values")
    if len(closes) < period + 1:
        return [None] * len(closes)

    changes = [current - previous for previous, current in zip(closes, closes[1:])]
    gains = [max(change, 0.0) for change in changes]
    losses = [max(-change, 0.0) for change in changes]
    average_gain = sum(gains[:period]) / period
    average_loss = sum(losses[:period]) / period
    values: list[float | None] = [None] * period

    def score(gain: float, loss: float) -> float:
        if gain == 0 and loss == 0:
            return 50.0
        if loss == 0:
            return 100.0
        if gain == 0:
            return 0.0
        relative_strength = gain / loss
        return 100.0 - (100.0 / (1.0 + relative_strength))

    values.append(score(average_gain, average_loss))
    for gain, loss in zip(gains[period:], losses[period:]):
        average_gain = ((period - 1) * average_gain + gain) / period
        average_loss = ((period - 1) * average_loss + loss) / period
        values.append(score(average_gain, average_loss))
    return values

Free RSI API FAQ