# Show HN: Pre-computed market context for agents

> Source: <https://tickerdb.com/>
> Published: 2026-05-28 04:39:18+00:00

# Market context

for agents.

Connect your agent to pre-computed market context that improves reasoning and reduces token usage.

No credit card required

``` bash
$ curl "https://api.tickerdb.com/v1/summary/NVDA" -H "Authorization: Bearer tdb_your_api_key"

{
  "ticker": "NVDA",
  "trend": {
    "direction": "strong_uptrend",
    "duration_days": 34,
    "ma_alignment": "aligned_bullish",
    "volume_confirmation": "confirmed"
  },
  "momentum": {
    "rsi_zone": "overbought",
    "macd_state": "expanding_positive",
    "divergence_detected": true
  },
  "extremes": {
    "condition": "overbought",
    "condition_rarity": "rare",
    "condition_percentile": 7.3
  },
  "resistance_level": {
    "status": "approaching",
    "distance_band": "very_close",
    "touch_count": 4
  },
  "fundamentals": {
    "valuation_zone": "undervalued",
    "growth_zone": "high_growth",
    "analyst_consensus": "strong_buy"
  }
}
```

## Improve reasoning with actionable context.

Before your agent can reason about an asset, it needs proper market context. TickerDB computes the context for you.

```
[
  {
    "date":   "2024-01-15",
    "open":   182.16,
    "high":   184.26,
    "low":    180.93,
    "close":  183.63,
    "volume": 65234100
  },
  // ... 200 more rows
]
```

- LLM has to compute raw data
- Uses more tokens
- Not designed for agents
- Inconsistent reasoning

```
{
  "trend": {
    "direction": "uptrend",
    "ma_alignment": "aligned_bullish"
  },
  "momentum": {
    "rsi_zone": "neutral_high"
  },
  "volatility": {
    "regime": "normal"
  }
}
```

- LLM reads categorical bands it understands
- Lower token usage
- Designed for agents
- Consistent reasoning

## The context your agent needs.

### Pre-computed

Our data is computed after market close and cached. Zero latency on your request - no indicator math, no delays.

### Categorical vocabulary

Responses use terms like `oversold`

, `uptrend`

, and `deeply_overvalued`

- the same vocabulary LLMs use to reason about markets.

### Fewer wasted tokens

A full asset summary is a fraction of the tokens you'd need to pass raw OHLCV. Your model gets more context, not more noise.

### Multi-source intelligence

Technical, fundamental, and analyst data in one response. No stitching together multiple providers.

### Per-asset behavioral context

Historical streaks, medians, and percentiles specific to each asset. Your agent knows what's unusual for *this* ticker.

### 5 years of queryable history

Every categorical field, every day, for 5 years. Just connect and query.

## Built for workflows agents struggle with.

TickerDB is strongest when your agent needs actionable market context, historical precedent, or watchlist diffs instead of raw price bars.

### Watchlist monitoring

Track saved assets and pull only what changed with `/v1/watchlist/changes`

. Ideal for daily alerts, portfolio briefings, and autonomous monitoring.

### Market scanning

Use `/v1/search`

to find oversold names, strong uptrends, rare conditions, or valuation mismatches across the full universe.

### Historical precedent

Query `/v1/summary`

with `field`

and `band`

to see when a setup last appeared and what happened after.

## Track state changes effortlessly.

TickerDB monitors your watchlist. When something meaningful changes, a structured diff is generated. Pull it on demand or get it pushed via webhooks.

`/v1/watchlist/changes`

```
{
  "timeframe": "daily",
  "run_date": "2026-03-28",
  "changes": {
    "AAPL": [
      {
        "field": "rsi_zone",
        "from":  "neutral",
        "to":    "oversold"
      },
      {
        "field": "divergence_detected",
        "from":  false,
        "to":    true
      }
    ],
    "TSLA": [
      {
        "field": "macd_state",
        "from":  "contracting_negative",
        "to":    "expanding_positive"
      }
    ],
    "BTCUSD": [
      {
        "field": "squeeze_active",
        "from":  false,
        "to":    true
      }
    ]
  },
  "tickers_checked": 12,
  "tickers_changed": 3
}
{
  "timeframe": "daily",
  "run_date": "2026-03-28",
  "changes": {
    "AAPL": [
      {
        "field": "rsi_zone",
        "from":  "neutral",
        "to":    "oversold"
      },
      {
        "field": "divergence_detected",
        "from":  false,
        "to":    true
      }
    ]
  },
  "tickers_checked": 12,
  "tickers_changed": 1
}
```

**Add tickers to your watchlist**

Track the assets you care about. Stocks, crypto, or both.

**TickerDB computes daily diffs**

After each pipeline run, every tracked field is compared against the prior day. Only assets with at least one change are included.

**Your agent reads only what changed**

No full snapshots to diff yourself. No wasted tokens on data that hasn't moved. Just the fields that shifted, with `from`

and `to`

values your agent can act on.

## Integrate in minutes.

Make your first call in minutes. Drop in our SDK or make direct HTTP calls.

``` bash
# Get a full market summary for AAPL
$ curl "https://api.tickerdb.com/v1/summary/AAPL" \
    -H "Authorization: Bearer YOUR_API_KEY"

# Search for oversold stocks
$ curl -G "https://api.tickerdb.com/v1/search" \
    --data-urlencode 'filters=[{"field":"momentum_rsi_zone","op":"eq","value":"oversold"}]' \
    -H "Authorization: Bearer YOUR_API_KEY"

# Get state changes on your watchlist
$ curl https://api.tickerdb.com/v1/watchlist/changes \
    -H "Authorization: Bearer YOUR_API_KEY"
python
import requests

# One call. Full market context.
res = requests.get(
    "https://api.tickerdb.com/v1/summary/AAPL",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = res.json()

# Hand it directly to your LLM
prompt = f"""
Analyze AAPL based on this market data:
{data}

Is this a good entry point?
"""

# Ready for your LLM
js
import { TickerDB } from 'tickerdb';

// One call. Full market context.
const client = new TickerDB({ apiKey: 'YOUR_API_KEY' });
const { data } = await client.summary('AAPL');

// Hand it directly to your LLM
const prompt = `Analyze AAPL based on this market data:
$${JSON.stringify(data)$}

Is this a good entry point?`;

// Ready for your LLM
import "context"
import "github.com/tickerdb/tickerdb-go"

// One call. Full market context.
client := tickerdb.NewClient("YOUR_API_KEY")
resp, _ := client.Summary(context.Background(), "AAPL", nil)

// Raw JSON plus rate limits
fmt.Println(string(resp.Data))
fmt.Println(resp.RateLimits.RequestsRemaining)
// claude_desktop_config.json
{
  "mcpServers": {
    "tickerdb": {
      "command": "npx",
      "args": ["tickerdb-mcp"],
      "env": {
        "TICKERDB_KEY": "YOUR_API_KEY"
      }
    }
  }
}
```

Once connected, Claude can call `get_summary`

, `get_search`

, `get_watchlist_changes`

, and more - directly from the chat. [all MCP tools →](/docs)

``` bash
# Install the TickerDB skill
$ clawhub install tickerdb

# Then just ask your agent
"How's AAPL looking? Give me the full summary."

"Add NVDA, AAPL, and BTCUSD to my watchlist and flag anything that changed."

"When was NVDA last deep_oversold, and what happened after?"
```

One install. Your agent gets summaries, search, watchlists, and schema - no config needed. [OpenClaw integration guide →](/openclaw)

## Compatible with everything.

MCP, OpenClaw, SDKs or plain HTTP. If it can make a GET request, it works with TickerDB.

**MCP Server**

Plug TickerDB into Claude Desktop or any MCP client. Your AI assistant pulls EOD market context from the chat.

[setup guide](/docs)

**Any agent framework**

LangChain, LlamaIndex, AutoGen, CrewAI - it's just HTTP. If it can make a GET request, it works.

[API reference](/docs)

**Python, Node.js & Go SDKs**

Official SDKs with typed responses. Or just use `fetch`

- the API is simple enough.

[get your API key](/docs/authentication)

## One database. Infinite ways to query.

Over 140 queryable fields across 10,000+ assets.