sign in
sign in
// django

Pre-computed market data for
Django apps.

TickerDB Python SDK + Django. Pre-computed market data in your views and API endpoints, no infrastructure.

try for free 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 views, five minutes.

Initialize the client at module level, call methods from your view functions. Every method returns a dictionary ready for JsonResponse.

python 
from django.http import JsonResponse
from tickerdb import TickerDB

client = TickerDB("tdb_your_api_key")

def summary_view(request, ticker):
    result = client.summary(ticker)
    return JsonResponse(result["data"])

def summary_events_view(request, ticker):
    field = request.GET.get("field", "rsi_zone")
    band = request.GET.get("band", "deep_oversold")
    result = client.summary(ticker, field=field, band=band)
    return JsonResponse(result["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 
def watchlist_changes_view(request):
    result = client.watchlist_changes()
    return JsonResponse(result["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
}
// django production pattern

Put market intelligence behind a service layer.

Django views are easier to test when TickerDB calls live in a small service module rather than being repeated across views, serializers, and management commands. The service can normalize ticker symbols, select the response fields your application owns, and translate upstream failures into one predictable application exception.

Because TickerDB serves end-of-day context, short application-level caching is usually a natural fit. Django's cache framework lets the same lookup serve templates, Django REST Framework views, Celery tasks, and scheduled portfolio reports without tying that choice to a specific Redis or Memcached deployment.

python services/market_context.py 
from django.conf import settings
from django.core.cache import cache
from tickerdb import TickerDB

client = TickerDB(settings.TICKERDB_API_KEY)

def market_context(ticker: str):
    symbol = ticker.upper()
    key = f"market-context:{symbol}"
    return cache.get_or_set(
        key,
        lambda: client.summary(symbol)["data"],
        timeout=300,
    )
// 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()

def briefing_view(request, 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 JsonResponse({"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 + django

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 data

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 docs