Build an AI trading agent, with Tickerbot.

An agent is only as good as what its tools return. Feed it raw market data and every answer starts with the model doing arithmetic in its context window; feed it computed state and the context goes to the decision. Tickerbot is the computed side as native tool calls — every ticker × every signal, queryable by the model itself.

Free plan. Every ticker, every signal, real-time data, all-time history.

the recipe

Tools in, decisions out.

1. Give the model the market — one config block installs the MCP server in Claude, ChatGPT, Cursor, or any MCP runtime — scans, tickers, series, news, and webhooks become tools the model calls itself:

{
  "mcpServers": {
    "tickerbot": {
      "command": "npx",
      "args": ["-y", "@tickerbot/mcp-server"],
      "env": { "TICKERBOT_API_KEY": "tb_live_…" }
    }
  }
}

2. Ask in English — the agent compiles the question into tool calls on its own. One prompt, one scan, computed answers back — the model never sees a raw bar:

You: which large caps went oversold this week while holding their 200-day?

Agent → tickerbot_scan({ q: "rsi_14 < 30 AND above_sma_200
                              AND market_cap > 1e10" })
      ← { count: 7, results: [ { ticker, price, rsi_14, … } × 7 ] }

Agent: Seven names match — here's the list, and what stands out…

3. Write the agent loop — for a headless agent, wire the same tools into your own loop — market state from Tickerbot, decisions from the model, execution through your broker’s API, on your schedule:

// Each cycle: state → decision → (maybe) action. Execution stays
// behind YOUR broker tool — Tickerbot's tools are read-only market state.
const tools = [...tickerbotTools, brokerTool, portfolioTool]

async function cycle() {
  const decision = await model.run({
    system: AGENT_POLICY,          // your rules: sizing, risk, approvals
    prompt: 'Review current positions and the watchlist. Act if warranted.',
    tools,
  })
  log(decision)                    // every action auditable
}
setInterval(cycle, 5 * 60 * 1000)

4. Let the market interrupt — polling on a timer wastes cycles when nothing changed. Subscribe the conditions the agent cares about and wake it on the webhook instead — the market becomes the scheduler:

curl -s -X POST https://api.tickerbot.io/v2/scan/subscribe \
  -H "Authorization: Bearer $TICKERBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "q": "rsi_14 < 30 AND above_sma_200 AND market_cap > 1e10",
        "target_url": "https://your-agent.example.com/wake" }'

# handler: app.post('/wake', () => cycle())  — the agent runs when
# something actually happened, with the matches already in hand.

under the hood

The calls behind it.

`MCP: @tickerbot/mcp-server`	Every endpoint as a native tool call — Claude, ChatGPT, Cursor, any runtime
`GET /docs/agents`	Copy-paste tool definitions for Claude, OpenAI, and MCP — auto-generated
`POST /v2/scan`	The agent’s workhorse — any question over the whole market, one call
`POST /v2/scan/subscribe`	Event-driven agents — wake on state change instead of polling

Every read runs in three tenses: live, as of any past moment (add ?asof= — no survivorship bias), or on push — the same query as a webhook that fires when the answer changes. Under all of it sits the computed table: every US equity plus rates, FX and crypto, every signal precomputed and refreshed continuously, with all-time history. That pipeline — warehouse, indicator math, refresh, point-in-time storage — is the part you’d otherwise build before writing your first line of product. Buy it as a table instead — data included; there’s no feed to bring.

questions

FAQ

Why does computed state matter for an agent?

Context economics. A model handed raw bars must spend its context window computing RSI, averages, and comparisons before it can think — slow, expensive, and error-prone. A model handed computed state gets 421+ signals as facts and spends the same context reasoning about them. One scan returns the answer set — a list, not a workload.

Does the agent execute trades?

Not through Tickerbot — our tools are read-only market state. Execution belongs behind your broker’s API as a separate tool you control, with your own policy, sizing, and approval rules in the loop. That separation is deliberate, and it’s what makes an agent auditable.

Why does a trading system need computed state?

Because every action it takes — an alert, a screen result, an order, a row in a user-facing app — is a condition over derived values: RSI below 30, price above the 200-day average, volume three times normal. Raw data doesn’t contain those. Something has to compute and refresh them for every symbol, continuously, and keep the history so past answers are reproducible. That’s a data pipeline, not a feature — you either build and operate it, or query one that already runs.

How does Tickerbot pricing work?

The Free plan needs no card and carries the full data side: every ticker, every signal, real-time data, all-time history and as-of queries. Paid plans start at $29/mo and add real-time webhooks, websocket streaming, and higher rate limits. Data depth is never a tier lever — every plan sees the same table.