Skip to content
Quantum Trader

Tickers

Manage stock symbols, configure data collection intervals, and track data fetch history.

Endpoints

Section titled “Endpoints”
MethodEndpointAuthDescription
POST/tickersNoCreate ticker
GET/tickersNoList tickers
GET/tickers/searchNoSearch tickers
GET/tickers/lookup/{symbol}NoLookup from Polygon
GET/tickers/{symbol}NoGet ticker details
PUT/tickers/{symbol}NoUpdate ticker
DELETE/tickers/{symbol}NoDelete ticker
GET/tickers/{symbol}/historyNoGet fetch history

Ticker Status

Section titled “Ticker Status”
StatusDescription
ACTIVEActively collecting data
INACTIVEData collection paused
DELISTEDStock no longer trading
ERRORData collection errors

Create Ticker

Section titled “Create Ticker”

Add a new symbol to track.

POST /api/v1/tickers
Content-Type: application/json


{
  "symbol": "NVDA",
  "name": "NVIDIA Corporation",
  "exchange": "NASDAQ",
  "sector": "Technology",
  "industry": "Semiconductors",
  "status": "ACTIVE",
  "priority": 1,
  "provider": "massive",
  "track_intervals": ["1m", "1d"],
  "auto_collect": true,
  "notes": "AI/GPU leader"
}

Request Fields

Section titled “Request Fields”
FieldTypeRequiredDefaultDescription
symbolstringYes-Stock ticker symbol
namestringNo-Company name
exchangestringNo-Stock exchange
sectorstringNo-Business sector
industrystringNo-Industry classification
statusstringNoACTIVETicker status
priorityintegerNo5Collection priority (1=highest)
providerstringNomassiveData provider
track_intervalsarrayNo[“1d”]Intervals to track
auto_collectbooleanNotrueStart collection immediately
notesstringNo-Custom notes

Track Intervals

Section titled “Track Intervals”
IntervalFieldDescription
1mtrack_1min1-minute bars
5mtrack_5min5-minute bars
15mtrack_15min15-minute bars
30mtrack_30min30-minute bars
1htrack_1h1-hour bars
1dtrack_dailyDaily bars
1wtrack_weeklyWeekly bars
1motrack_monthlyMonthly bars

Lookup Ticker

Section titled “Lookup Ticker”

Fetch ticker info from Polygon before adding.

GET /api/v1/tickers/lookup/NVDA

Get Ticker Details

Section titled “Get Ticker Details”

Get ticker with data point counts.

GET /api/v1/tickers/AAPL

Response Fields

Section titled “Response Fields”
FieldDescription
datapoint_countsNumber of data points per interval
massive_dataExtended data from Polygon API

Search Tickers

Section titled “Search Tickers”

Search tickers by symbol or name.

GET /api/v1/tickers/search?query=apple&limit=10
{
  "results": [
    {"symbol": "AAPL", "name": "Apple Inc."},
    {"symbol": "APLE", "name": "Apple Hospitality REIT"}
  ],
  "count": 2
}

List Tickers

Section titled “List Tickers”

Get all tracked tickers with optional filtering.

GET /api/v1/tickers?status=ACTIVE&limit=100

Query Parameters

Section titled “Query Parameters”
ParameterTypeDescription
statusstringFilter by status
sectorstringFilter by sector
providerstringFilter by provider
limitintegerMax results (default: 100)
offsetintegerPagination offset

Get Fetch History

Section titled “Get Fetch History”

View data collection history for a ticker.

GET /api/v1/tickers/AAPL/history

Fetch Status Values

Section titled “Fetch Status Values”
StatusDescription
PENDINGScheduled, not started
IN_PROGRESSCurrently fetching
COMPLETEDSuccessfully finished
FAILEDError occurred
PARTIALPartially completed

Update Ticker

Section titled “Update Ticker”

Modify ticker configuration.

PUT /api/v1/tickers/AAPL
Content-Type: application/json


{
  "status": "ACTIVE",
  "priority": 1,
  "track_intervals": ["1m", "15m", "1d"],
  "notes": "Updated tracking intervals"
}

Code Examples

Section titled “Code Examples”

JavaScript/TypeScript

Section titled “JavaScript/TypeScript”
const api = axios.create({
  baseURL: 'http://localhost:8501/api/v1'
});


// Lookup and create ticker
async function addTicker(symbol) {
  // First lookup to get company info
  const { data: info } = await api.get(`/tickers/lookup/${symbol}`);


  // Create ticker with auto-populated data
  const { data: ticker } = await api.post('/tickers', {
    symbol: info.symbol,
    name: info.name,
    exchange: info.exchange,
    sector: info.sector,
    industry: info.industry,
    status: 'ACTIVE',
    priority: 1,
    track_intervals: ['1m', '1d'],
    auto_collect: true
  });


  console.log(`Added ${ticker.symbol}: ${ticker.name}`);
  return ticker;
}


// Get tickers with data counts
async function getTickersWithData() {
  const { data: tickers } = await api.get('/tickers', {
    params: { status: 'ACTIVE' }
  });


  console.log('Active tickers:');
  for (const ticker of tickers) {
    const counts = ticker.datapoint_counts || {};
    const total = Object.values(counts).reduce((a, b) => a + b, 0);
    console.log(`  ${ticker.symbol}: ${total.toLocaleString()} data points`);
  }


  return tickers;
}


// Check fetch history
async function checkFetchStatus(symbol) {
  const { data } = await api.get(`/tickers/${symbol}/history`);


  console.log(`\nFetch history for ${symbol}:`);
  for (const fetch of data.history.slice(0, 5)) {
    const status = fetch.status === 'COMPLETED' ? '✅' : '❌';
    console.log(`  ${status} ${fetch.interval}: ${fetch.records_fetched.toLocaleString()} records`);
  }
}


// Usage
await addTicker('NVDA');
await getTickersWithData();
await checkFetchStatus('AAPL');

Python

Section titled “Python”
import requests
from typing import List, Dict, Optional


class TickerManager:
    def __init__(self, base_url: str):
        self.base_url = base_url


    def lookup(self, symbol: str) -> Dict:
        """Lookup ticker info from Polygon."""
        response = requests.get(f"{self.base_url}/tickers/lookup/{symbol}")
        response.raise_for_status()
        return response.json()


    def create(
        self,
        symbol: str,
        intervals: List[str] = ["1d"],
        auto_collect: bool = True
    ) -> Dict:
        """Create a new ticker."""
        # Lookup first
        info = self.lookup(symbol)


        response = requests.post(
            f"{self.base_url}/tickers",
            json={
                "symbol": symbol,
                "name": info.get("name"),
                "exchange": info.get("exchange"),
                "sector": info.get("sector"),
                "industry": info.get("industry"),
                "status": "ACTIVE",
                "track_intervals": intervals,
                "auto_collect": auto_collect
            }
        )
        response.raise_for_status()
        return response.json()


    def list_active(self) -> List[Dict]:
        """List all active tickers."""
        response = requests.get(
            f"{self.base_url}/tickers",
            params={"status": "ACTIVE"}
        )
        response.raise_for_status()
        return response.json()


    def get_history(self, symbol: str) -> List[Dict]:
        """Get fetch history for a ticker."""
        response = requests.get(f"{self.base_url}/tickers/{symbol}/history")
        response.raise_for_status()
        return response.json()["history"]


    def get_data_summary(self) -> Dict[str, int]:
        """Get total data points per ticker."""
        tickers = self.list_active()
        summary = {}


        for ticker in tickers:
            counts = ticker.get("datapoint_counts", {})
            total = sum(counts.values())
            summary[ticker["symbol"]] = total


        return summary




# Usage
manager = TickerManager("http://localhost:8501/api/v1")


# Add new ticker
ticker = manager.create("NVDA", intervals=["1m", "1d"])
print(f"Added {ticker['symbol']}")


# List active tickers
active = manager.list_active()
print(f"Active tickers: {len(active)}")


# Data summary
summary = manager.get_data_summary()
for symbol, count in sorted(summary.items(), key=lambda x: -x[1])[:10]:
    print(f"  {symbol}: {count:,} data points")


# Check fetch history
history = manager.get_history("AAPL")
for fetch in history[:5]:
    status = "✅" if fetch["status"] == "COMPLETED" else "❌"
    print(f"  {status} {fetch['interval']}: {fetch['records_fetched']:,} records")

Best Practices

Section titled “Best Practices”

Lookup First

Use /tickers/lookup to auto-populate company info before creating.

Priority Planning

Assign higher priority (lower number) to frequently traded symbols.

Interval Selection

Only track intervals you actually need to save storage and API calls.

Monitor History

Regularly check fetch history to catch collection errors early.