TickerAPI for Go.

Strongly-typed client for the TickerAPI HTTP API. Idiomatic Go, full struct definitions, and context support. Install and start pulling market data immediately.

One command. Ready to go.

Install the SDK and start pulling market data in under a minute.

install
// install the sdk
go get github.com/tickerapi/tickerapi-go
go
package main

import (
    "fmt"
    tickerapi "github.com/tickerapi/tickerapi-go"
)

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

    summary, _ := client.GetSummary("AAPL", nil)
    fmt.Println(summary.Trend.Direction)   // "uptrend"
    fmt.Println(summary.Momentum.RSIZone)  // "neutral_high"
}

view on pkg.go.dev →

Chain calls. Build context.

Scan for oversold stocks, pull a full summary on the top pick, then compare it against peers. Each method returns strongly-typed structs with categorical data.

1
client.ScanOversold(&ScanOpts{Sector: "Technology"})
Returns slice of oversold tech tickers with severity rankings
2
client.GetSummary("NVDA", nil)
Full categorical breakdown — trend, momentum, volatility, fundamentals
3
client.Compare([]string{"NVDA", "AMD"}, nil)
Side-by-side comparison across all dimensions

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.

go
summary, _ := client.GetSummary("AAPL", nil)
json
{
  "ticker": "AAPL",
  "changes": [
    {
      "field": "rsi_zone",
      "from": "neutral",
      "to": "oversold"
    },
    {
      "field": "trend",
      "from": "uptrend",
      "to": "downtrend"
    }
  ]
}

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",
  "trend": "strong_uptrend",
  "momentum": {
    "rsi_zone": "overbought",
    "macd_signal": "bullish"
  },
  "volatility": "high",
  "fundamentals": {
    "pe_zone": "above_historical_avg",
    "earnings_surprise": "positive"
  }
}

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)

Register a webhook URL for watchlist change notifications.

client.ListWebhooks()

List your registered webhook URLs.

client.DeleteWebhook(id)

Remove a registered webhook.

Built for how code consumes data.

Categorical data, less parsing

Responses like "rsi_zone": "oversold" are ready to branch on. No indicator math, no threshold logic.

Strongly-typed structs

Every response maps to Go structs. Full IDE autocomplete, compile-time safety, no interface{}{} casting.

Pre-computed daily

No infrastructure to maintain. No cron jobs, no indicator math, no data pipelines. TickerAPI handles computation and syncing.

Start building.

Get an API key and go get the SDK. No credit card required.