sign in
sign in
// flask

Market data for
Flask apps.

TickerDB Python SDK + Flask. Pre-computed market data in your routes, no infrastructure.

try for free read the docs
// setup

Install the SDK.

One dependency. No MCP server, no WebSocket connections — just a Python package that calls the TickerDB HTTP API.

terminal 
$ pip install tickerdb
// code example

Two routes, five minutes.

Initialize the client once, call methods from your route functions. Every method returns a dictionary ready for jsonify.

python 
from flask import Flask, jsonify, request
from tickerdb import TickerDB

app = Flask(__name__)
client = TickerDB("tapi_your_api_key")

@app.route("/summary/<ticker>")
def get_summary(ticker):
    return jsonify(client.summary(ticker))

@app.route("/summary-events/<ticker>")
def get_summary_events(ticker):
    field = request.args.get("field", "rsi_zone")
    band = request.args.get("band", "deep_oversold")
    return jsonify(client.summary(ticker, field=field, band=band))
// state changes

Track state changes effortlessly.

Most market data APIs return point-in-time snapshots. TickerDB tracks state transitions — your agent sees what changed, not just what is.

python 
@app.route("/watchlist/changes")
def watchlist_changes():
    changes = client.watchlist.changes(
        tickers=["AAPL", "MSFT", "GOOGL"]
    )
    # each change includes from/to state transitions
    # e.g. trend: "uptrend" → "downtrend"
    return jsonify(changes)
json 
{
  "ticker": "AAPL",
  "changes": [
    {
      "field": "rsi_zone",
      "from": "neutral",
      "to": "oversold"
    },
    {
      "field": "trend",
      "from": "uptrend",
      "to": "downtrend"
    }
  ]
}
// ai integration

Feed an AI agent.

TickerDB's categorical output is designed for LLMs. Feed a summary directly into a prompt — the model already understands terms like "oversold" and "strong_uptrend" without extra context.

python 
import anthropic
from tickerdb import TickerDB

client = TickerDB("tapi_your_api_key")
ai = anthropic.Anthropic()

@app.route("/briefing/<ticker>")
def get_briefing(ticker):
    summary = client.summary(ticker)

    message = ai.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"Analyze this market data for {ticker} and provide a brief:\n{summary}"
        }]
    )

    return jsonify({"analysis": message.content})
// available methods

What you can call.

Every method returns categorical, pre-computed data as a plain dictionary. No raw data to parse, no indicators to compute.

client.get_summary(ticker)

Full technical + fundamental snapshot for a single asset.

client.get_watchlist()

Batch summaries for a portfolio.

client.get_watchlist_changes()

Field-level diffs for your watchlist since the last pipeline run.

client.add_to_watchlist(tickers)

Add tickers to your persistent watchlist.

client.remove_from_watchlist(tickers)

Remove tickers from your watchlist.

client.search(filters)

Search across all assets with multi-field filters.

client.get_schema()

Discover all queryable fields and their types.

client.get_account()

Your plan tier, rate limits, and current API usage.

client.create_webhook(url)

Register a webhook URL for watchlist change notifications.

client.list_webhooks()

List your registered webhook URLs.

client.delete_webhook(id)

Remove a registered webhook.

full method reference →
// what your agent sees

What your agent sees.

Every tool returns categorical facts — not raw OHLCV data. Your agent can branch on "oversold" without needing to know what RSI > 70 means.

json 
{
  "ticker": "NVDA",
  "trend": "strong_uptrend",
  "momentum": {
    "rsi_zone": "overbought",
    "macd_signal": "bullish"
  },
  "volatility": "high",
  "fundamentals": {
    "pe_zone": "above_historical_avg",
    "earnings_surprise": "positive"
  }
}
// why tickerdb + flask

Built for how agents consume data.

Categorical data, less prompt engineering

Responses like "rsi_zone": "oversold" are already in a format the model understands. No need to explain what RSI > 70 means.

Compact responses

Tool-call context windows are limited. TickerDB responses are a fraction of the tokens you'd need to pass raw OHLCV data.

Pre-computed daily

No infrastructure to maintain. No cron jobs, no indicator math, no data pipelines. TickerDB handles computation and syncing.

Start building.

Try for free. No credit card required.

try for free read the docs