sign in
sign in
// flask

Market context for
Flask apps.

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

try for free playground
// 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("tdb_your_api_key")

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

@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)["data"])
// 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()
    # each change includes from/to state transitions
    # e.g. trend: "uptrend" → "downtrend"
    return jsonify(changes["data"])
json 
{
  "timeframe": "daily",
  "run_date": "2026-03-28",
  "changes": {
    "AAPL": [
      {
        "field": "rsi_zone",
        "from": "neutral",
        "to": "oversold"
      },
      {
        "field": "trend_direction",
        "from": "uptrend",
        "to": "downtrend"
      }
    ]
  },
  "ticker_context": {
    "AAPL": {
      "last_changed_date": "2026-03-28"
    }
  },
  "tickers_checked": 2,
  "tickers_changed": 1
}
// ai integration

Feed an AI agent.

TickerDB's categorical-first 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("tdb_your_api_key")
ai = anthropic.Anthropic()

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

    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 a dict with `data` and `rate_limits`. No raw data to parse, no indicator math to maintain.

client.summary("AAPL")

Full technical + fundamental snapshot for a single asset.

client.search(filters={...})

Search across all assets with multi-field filters.

client.schema()

Discover all queryable fields and their types.

client.watchlist(["AAPL"])

Batch EOD summaries for a portfolio.

client.watchlist_changes()

State changes for your saved watchlist tickers.

client.create_webhook(url=...)

Create a webhook for watchlist change alerts.

client.list_webhooks()

List the webhooks on your account.

client.delete_webhook(id)

Delete a webhook you no longer need.

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",
  "data_status": "eod",
  "as_of_date": "2026-04-11",
  "trend": {
    "direction": "strong_uptrend",
    "ma_alignment": "aligned_bullish"
  },
  "momentum": {
    "rsi_zone": "overbought",
    "macd_state": "expanding_positive",
    "direction": "accelerating"
  },
  "volatility": {
    "regime": "normal",
    "regime_trend": "stable"
  },
  "fundamentals": {
    "valuation_zone": "fair_value",
    "pe_vs_historical_zone": "premium",
    "last_earnings_surprise": "beat"
  }
}
// why tickerdb + flask

Built for how agents consume data.

Market-state 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. TickerDB handles computation and syncing.

Start building.

Try for free. No credit card required.

try for free playground