// gin

Market context for
Gin apps.

TickerDB Go SDK + Gin. Pre-computed market data in your handlers, no infrastructure.

// setup

Install the SDK.

One dependency. No MCP server, no WebSocket connections — just a Go module that calls the TickerDB HTTP API.

terminal

$ go get github.com/tickerdb/tickerdb-go

// code example

Two handlers, five minutes.

Initialize the client once, call methods from your handlers, and return the raw JSON payload from resp.Data.

package main

import (
    "github.com/gin-gonic/gin"
    tickerdb "github.com/tickerdb/tickerdb-go"
)

func main() {
    client := tickerdb.NewClient("tdb_your_api_key")
    r := gin.Default()

    r.GET("/summary/:ticker", func(c *gin.Context) {
        resp, _ := client.Summary(c.Request.Context(), c.Param("ticker"), nil)
        c.Data(200, "application/json", resp.Data)
    })

    r.GET("/events/:ticker", func(c *gin.Context) {
        field := c.DefaultQuery("field", "rsi_zone")
        band := c.DefaultQuery("band", "deep_oversold")
        resp, _ := client.Summary(c.Request.Context(), c.Param("ticker"), &tickerdb.SummaryOptions
            Field: tickerdb.Ptr(field),
            Band:  tickerdb.Ptr(band),
        )
        c.Data(200, "application/json", resp.Data)
    })

    r.Run(":8080")
}

// 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.

r.GET("/watchlist/changes", func(c *gin.Context) {
    resp, _ := client.WatchlistChanges(c.Request.Context(), nil)
    c.Data(200, "application/json", resp.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.

r.GET("/briefing/:ticker", func(c *gin.Context) {
    summary, _ := client.Summary(c.Request.Context(), c.Param("ticker"), nil)

    message, _ := anthropicClient.Messages.New(context.TODO(),
        anthropic.MessageNewParams{
            Model:     anthropic.ModelClaudeSonnet4_20250514,
            MaxTokens: 1024,
            Messages: []anthropic.MessageParam{
                anthropic.NewUserMessage(
                    anthropic.NewTextBlock(
                        "Analyze this market data and provide a brief:\n" + string(summary.Data),
                    ),
                ),
            },
        },
    )

    c.JSON(200, gin.H{"analysis": message.Content})
})

// available methods

What you can call.

Every call returns a response wrapper with `Data` and `RateLimits`. Unmarshal what you need and keep moving.

client.Summary(ctx, "AAPL", nil)

Full technical + fundamental snapshot for a single asset.

client.Search(ctx, opts)

Search across all assets with multi-field filters.

client.Schema(ctx)

Discover all queryable fields and their types.

client.Watchlist(ctx, tickers, nil)

Batch EOD summaries for a portfolio.

client.WatchlistChanges(ctx, nil)

State changes for your saved watchlist tickers.

client.CreateWebhook(ctx, req)

Create a webhook for watchlist change alerts.

client.ListWebhooks(ctx)

List the webhooks on your account.

client.DeleteWebhook(ctx, req)

Delete a webhook you no longer need.

full method reference

// why tickerdb + gin

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.

// 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.