// gin

Market data for
Gin apps.

TickerAPI 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 TickerAPI HTTP API.

terminal

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

// code example

Two handlers, five minutes.

Initialize the client once, call methods from your handlers. Every method returns a struct ready for c.JSON.

package main

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

func main() {
    client := tickerapi.NewClient("tapi_your_api_key")
    r := gin.Default()

    r.GET("/summary/:ticker", func(c *gin.Context) {
        summary, _ := client.Summary(c.Param("ticker"))
        c.JSON(200, summary)
    })

    r.GET("/scan/oversold", func(c *gin.Context) {
        results, _ := client.Scan.Oversold(&tickerapi.ScanOptions{
            Sector: c.Query("sector"),
        })
        c.JSON(200, results)
    })

    r.Run(":8080")
}

// state changes

Track state changes effortlessly.

Most market data APIs return point-in-time snapshots. TickerAPI tracks state transitions — your agent sees what changed, not just what is.

r.GET("/watchlist/changes", func(c *gin.Context) {
    changes, _ := client.Watchlist.Changes()
    c.JSON(200, changes)
})

json

{
  "ticker": "AAPL",
  "changes": [
    {
      "field": "rsi_zone",
      "from": "neutral",
      "to": "oversold"
    },
    {
      "field": "trend",
      "from": "uptrend",
      "to": "downtrend"
    }
  ]
}

// ai integration

Feed an AI agent.

TickerAPI's categorical 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.Param("ticker"))
    data, _ := json.Marshal(summary)

    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(data),
                    ),
                ),
            },
        },
    )

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

// available methods

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.GetSummary(ticker, opts)

Full technical + fundamental snapshot for a single asset.

client.Compare(tickers, opts)

Side-by-side comparison of multiple assets.

client.ListAssets()

Browse all supported tickers.

client.ListSectors()

List all valid sector values with asset counts.

client.GetWatchlist(tickers, opts)

Batch summaries for a portfolio.

client.GetWatchlistChanges(opts)

Field-level diffs for your watchlist since the last pipeline run.

client.AddToWatchlist(tickers)

Add tickers to your persistent watchlist.

client.RemoveFromWatchlist(tickers)

Remove tickers from your watchlist.

client.ScanOversold(opts)

Assets in oversold conditions.

client.ScanOverbought(opts)

Assets in overbought RSI conditions with severity rankings.

client.ScanBreakouts(opts)

Support/resistance breakouts.

client.ScanUnusualVolume(opts)

Volume anomalies.

client.ScanValuation(opts)

Valuation extremes.

client.ScanInsiderActivity(opts)

Insider buying/selling patterns.

client.GetAccount()

Your plan tier, rate limits, and current API usage.

client.CreateWebhook(url)

client.ListWebhooks()

List your registered webhook URLs.

client.DeleteWebhook(id)

Remove a registered webhook.

full method reference →

// why tickerapi + gin

Built for how agents consume data.

Categorical 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. TickerAPI 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, no data pipelines. TickerAPI 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.