TickerDB for Python.

Simple client for the TickerDB HTTP API. Install with pip, initialize with your API key, and start pulling pre-computed market data immediately.

Install and call in seconds.

One pip install, one import, one line to initialize. Every method returns a plain dictionary.

install
pip install tickerdb
python
from tickerdb import TickerDB

client = TickerDB("tapi_your_api_key")

# Get a full summary for any ticker
summary = client.get_summary("AAPL")
print(summary["trend"]["direction"])    # "uptrend"
print(summary["momentum"]["rsi_zone"])  # "neutral_high"

view on PyPI →

Chain calls. Build context.

Pull a summary, use summary event mode for historical band transitions, then monitor your watchlist for changes. Each method returns categorical data you can branch on directly.

1
client.get_summary("AAPL")
Full categorical breakdown — trend, momentum, volatility, fundamentals
2
client.get_summary("AAPL", field="rsi_zone", band="deep_oversold")
Ticker event history for RSI entering deep oversold
3
client.get_watchlist_changes()
State changes across your monitored tickers

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
summary = client.get_summary("AAPL")
json
{
  "ticker": "AAPL",
  "changes": [
    {
      "field": "rsi_zone",
      "from": "neutral",
      "to": "oversold"
    },
    {
      "field": "trend",
      "from": "uptrend",
      "to": "downtrend"
    }
  ]
}

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"
  }
}

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.

Built for how code consumes data.

Categorical data, less parsing

Responses like "rsi_zone": "oversold" are ready to branch on. No indicator math, no threshold logic.

Plain dictionaries

Every method returns a dict. No ORM, no custom objects, no serialization steps. JSON in, dict out.

Pre-computed daily

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

Start building.

pip install tickerdb. No credit card required for the free tier.