| name | injective-ai-cost-optimization |
| description | Optimize AI API costs for agentic trading bots. Covers Anthropic token cost tracking, web search cost management, CoinGecko/Massive.com data sourcing, shared caching strategies, and per-user cost caps. Learned from real production data showing web search inflates costs 10-17x. |
| license | MIT |
| metadata | {"author":"ckhbtc","version":"1.0.0","filePattern":["**/triggers*","**/technicals*","**/strategies*"],"bashPattern":["anthropic","coingecko","massive"]} |
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):
| Call Type | Input Tokens | Output Tokens | Cost/Call | Daily (96 calls) |
|---|
With web search (web_search_20250305) | 20,000–44,000 | ~1,000 | $0.03–0.05 | $3–5/user |
| Without search (technicals only) | 650–2,600 | ~500 | $0.003 | $0.30/user |
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
| Asset Class | Source | Cost | What You Get |
|---|
| Crypto (BTC, ETH, etc.) | CoinGecko free tier | Free (no API key) | 200 daily closes, 7d/14d/30d/60d/200d/1y changes, market cap, volume, ATH |
| Equities (NVDA, TSLA, etc.) | Massive.com API | API key required | 200+ daily OHLC bars, volume |
| Forex (EUR, GBP) | Massive.com API | C:EURUSD format | Same as equities |
| Commodities (XAU, XAG) | Massive.com API | C:XAUUSD format | Same as equities |
| Oil | Massive.com API | USO (ETF ticker) | Same as equities |
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 { } 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:
| Indicator | Formula | Use |
|---|
| EMA(9/21/50/200) | Exponential moving average | Trend direction |
| MACD(12,26,9) | EMA(12) - EMA(26), signal = EMA(9) of MACD | Momentum + crossovers |
| RSI(14) | Relative strength index | Overbought/oversold |
| Bollinger Bands(20,2) | Mean ± 2σ of last 20 closes | Volatility + breakouts |
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:
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)
| Interval | Calls/Day | Token Cost/User | Use Case |
|---|
| 5 min | 288 | ~$0.86 | Scalping (too expensive for most) |
| 15 min | 96 | ~$0.29 | Active trading (recommended default) |
| 30 min | 48 | ~$0.14 | Swing trading |
| 1 hour | 24 | ~$0.07 | Position trading |
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
5. Model Selection
| Model | Input/M | Output/M | Best For |
|---|
| Haiku 4.5 | $0.80 | $4.00 | Trading signals (default, fast, cheap) |
| Sonnet 4 | $3.00 | $15.00 | Complex analysis (4x more expensive) |
Haiku is sufficient for structured signal generation from technical data.
Pricing for x402 / Subscription
Based on production data:
| Metric | Value |
|---|
| Cost per tick (no search) | ~$0.003 |
| Cost per user per day (15 min, 1 strategy) | ~$0.30 |
| Cost per user per day (15 min, 3 strategies) | ~$0.90 |
| Worst case per user per day | ~$2.90 |
| Suggested x402 price per tick | $0.01–0.03 (3-10x markup) |
| Suggested monthly subscription | $15–30/user |
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.
