injective-ai-cost-optimization

AI Cost Optimization for Agentic Trading

Real-world cost data from production deployment on Injective DEX with Claude Haiku 4.5.

When to Apply

• When building AI-powered trading bots that make periodic API calls
• When optimizing Anthropic/OpenAI API spend for multi-user platforms
• When choosing between web search, external data APIs, and cached data
• When setting per-user cost limits or pricing for x402/subscription models

Cost Reality: Web Search vs Technical Indicators

Production data (Claude Haiku 4.5, 15-min intervals):

Web search is 10-17x more expensive — not because of the $0.01/search fee, but because Anthropic injects 20K-44K tokens of web page content into the input context.

Architecture: Shared Data Cache

The Key Insight

Market data is the same for all users. Don't fetch it per-user — cache it globally.

CoinGecko (crypto) ──┐
                      ├── Shared Cache (15 min TTL) ──→ All user AI calls
Massive.com (equities)┘

Data Sources

CoinGecko Free Tier Endpoints

# Per-coin detailed data (7d/30d/200d changes, ATH, volume)
GET /api/v3/coins/{id}?localization=false&tickers=false&community_data=false&developer_data=false

# 200 daily closes for technical indicators
GET /api/v3/coins/{id}/market_chart?vs_currency=usd&days=200&interval=daily

Rate limits: 5-15 calls/minute (free), 30/minute (demo key). Add 1.5s delay between requests. Use optimistic lock to prevent thundering herd:

let _fetchInProgress = false
if (staleSymbols.length > 0 && !_fetchInProgress) {
  _fetchInProgress = true
  try { /* fetch */ } finally { _fetchInProgress = false }
}

Massive.com API

GET /v2/aggs/ticker/{ticker}/range/1/day/{from}/{to}?apiKey={key}&limit=250&sort=asc&adjusted=true

Tickers: stocks direct (NVDA), forex with C: prefix (C:EURUSD), commodities (C:XAUUSD, USO for oil).

Technical Indicators from Cached Data

Compute these from 200 daily closes — zero API cost:

These replace web search entirely. The AI gets structured data (EMAs, MACD signal, RSI value) instead of 40K tokens of raw web pages. Better signal, 10x cheaper.

Per-Call Cost Tracking

Log token counts from every Anthropic response:

const inputTokens = response.usage?.input_tokens ?? 0
const outputTokens = response.usage?.output_tokens ?? 0
const HAIKU_INPUT_PER_M = 0.80
const HAIKU_OUTPUT_PER_M = 4.00
const tokenCost = (inputTokens * HAIKU_INPUT_PER_M + outputTokens * HAIKU_OUTPUT_PER_M) / 1_000_000
logger.info({ inputTokens, outputTokens, tokenCost: `$${tokenCost.toFixed(4)}` }, 'API call cost')

Admin-Only Cost Dashboard

Expose a /api/costs endpoint with rolling 24h summary:

// Protect with admin wallet check
const admins = (process.env.ADMIN_WALLETS ?? '').split(',').map(s => s.trim())
if (!admins.includes(wallet)) return c.json({ error: 'Admin access required' }, 403)
return c.json(getCostSummary())

Cost Control Levers

1. Poll Interval (biggest lever)

2. Symbol Count per Strategy

Output tokens scale linearly with symbol count. Cap at 10 symbols per strategy:

max_tokens: Math.max(1024, strategy.symbols.length * 200)

At 9 symbols with 1024 max_tokens, the AI runs out of space and returns truncated (unparseable) JSON.

3. Strategy Count per User

Cap at 3 strategies per user. Each strategy = 1 AI call per tick. Maximum cost exposure = 3 strategies × 10 symbols × 96 ticks/day = ~$2.90/day.

4. Web Search (disabled by default)

If re-enabling, use a shared cache:

const NEWS_CACHE_TTL_MS = 60 * 60 * 1000 // 1 hour
// One search for ALL users, cache per symbol
// Reduces 100 users × 96 ticks = 9,600 searches/day to ~24 searches/day

5. Model Selection

Haiku is sufficient for structured signal generation from technical data.

Pricing for x402 / Subscription

Based on production data:

Anti-Patterns

• Web search on every tick — 10-17x cost for marginal value. Use cached technicals.
• Per-user data fetches — CoinGecko/Massive data is identical for all users. Cache globally.
• No max_tokens scaling — fixed 2048 tokens for 2 symbols wastes money. Scale with symbol count.
• Permanent faucet blocklist — if faucet amount is wrong, user can never retry. Use time-based cooldown.
• No cost logging — you can't optimize what you can't measure. Log every response.usage.