Build a Hybrid Gold Price API That Saves $200/Month on Data Costs

// package.json
{
  "dependencies": {
    "express": "^4.18.2",
    "axios": "^1.6.0",
    "redis": "^4.6.0",
    "dotenv": "^16.3.1"
  }
}

// .env
FREE_API_KEY=your_metals_dev_key
PAID_API_KEY=your_metals_api_key
REDIS_URL=redis://localhost:6379
CACHE_TTL=60
MAX_FREE_REQUESTS_PER_HOUR=200

npm install
redis-server --daemonize yes

// goldApiClient.js
const axios = require('axios');
const redis = require('redis');

class GoldApiClient {
  constructor() {
    this.redisClient = redis.createClient({ url: process.env.REDIS_URL });
    this.redisClient.connect();
    
    // Track API health
    this.freeApiFailures = 0;
    this.maxFailuresBeforePaid = 3; // Switch after 3 consecutive failures
    
    // Personal note: Learned this after burning through my paid quota in 2 days
    this.requestCounts = {
      free: 0,
      paid: 0,
      cached: 0
    };
  }

  async getGoldPrice() {
    // Step 1: Check cache first
    const cached = await this.redisClient.get('gold_price');
    if (cached) {
      this.requestCounts.cached++;
      return JSON.parse(cached);
    }

    // Step 2: Try free API if it's healthy
    if (this.freeApiFailures < this.maxFailuresBeforePaid) {
      try {
        const freeData = await this.fetchFromFreeApi();
        this.freeApiFailures = 0; // Reset on success
        await this.cachePrice(freeData);
        return freeData;
      } catch (error) {
        this.freeApiFailures++;
        console.warn(`Free API failed (attempt ${this.freeApiFailures}/3):`, error.message);
        // Watch out: Don't throw here - fall through to paid API
      }
    }

    // Step 3: Use paid API as fallback
    try {
      const paidData = await this.fetchFromPaidApi();
      await this.cachePrice(paidData);
      return paidData;
    } catch (error) {
      // Both failed - return stale cache or throw
      const staleCache = await this.redisClient.get('gold_price_stale');
      if (staleCache) {
        console.error('Both APIs down, returning stale data');
        return { ...JSON.parse(staleCache), isStale: true };
      }
      throw new Error('All gold price sources unavailable');
    }
  }

  async fetchFromFreeApi() {
    const response = await axios.get('https://api.metals.dev/v1/latest', {
      params: { 
        api_key: process.env.FREE_API_KEY,
        currency: 'USD',
        unit: 'oz'
      },
      timeout: 5000 // Fail fast
    });
    
    this.requestCounts.free++;
    return {
      price: response.data.metals.gold,
      source: 'free',
      timestamp: Date.now()
    };
  }

  async fetchFromPaidApi() {
    const response = await axios.get('https://metals-api.com/api/latest', {
      params: { 
        access_key: process.env.PAID_API_KEY,
        base: 'XAU',
        symbols: 'USD'
      },
      timeout: 3000
    });
    
    this.requestCounts.paid++;
    return {
      price: 1 / response.data.rates.USD, // Invert rate to get price per oz
      source: 'paid',
      timestamp: Date.now()
    };
  }

  async cachePrice(data) {
    const ttl = parseInt(process.env.CACHE_TTL) || 60;
    await this.redisClient.setEx('gold_price', ttl, JSON.stringify(data));
    // Keep stale backup for 1 hour
    await this.redisClient.setEx('gold_price_stale', 3600, JSON.stringify(data));
  }

  getStats() {
    return this.requestCounts;
  }
}

module.exports = GoldApiClient;

// server.js
const express = require('express');
const GoldApiClient = require('./goldApiClient');

const app = express();
const goldClient = new GoldApiClient();

app.get('/api/gold/price', async (req, res) => {
  try {
    const priceData = await goldClient.getGoldPrice();
    
    res.json({
      success: true,
      data: {
        pricePerOz: priceData.price.toFixed(2),
        currency: 'USD',
        source: priceData.source,
        timestamp: priceData.timestamp,
        isStale: priceData.isStale || false
      }
    });
  } catch (error) {
    res.status(503).json({
      success: false,
      error: 'Gold price data temporarily unavailable',
      details: error.message
    });
  }
});

// Stats endpoint - shows where your requests are going
app.get('/api/gold/stats', (req, res) => {
  const stats = goldClient.getStats();
  const total = stats.free + stats.paid + stats.cached;
  
  res.json({
    totalRequests: total,
    breakdown: {
      cached: `${stats.cached} (${((stats.cached/total)*100).toFixed(1)}%)`,
      free: `${stats.free} (${((stats.free/total)*100).toFixed(1)}%)`,
      paid: `${stats.paid} (${((stats.paid/total)*100).toFixed(1)}%)`
    },
    estimatedMonthlyCost: (stats.paid * 0.0006 * 30).toFixed(2) // $0.0006 per request
  });
});

app.listen(3000, () => {
  console.log('Gold API running on http://localhost:3000');
  console.log('Try: curl http://localhost:3000/api/gold/price');
});

// test-cascade.js
const GoldApiClient = require('./goldApiClient');

async function testCascade() {
  const client = new GoldApiClient();
  
  console.log('Test 1: Normal operation (should use free API)');
  let price = await client.getGoldPrice();
  console.log(`✓ Price: $${price.price}, Source: ${price.source}`);
  
  console.log('\nTest 2: Cached request (should be instant)');
  const start = Date.now();
  price = await client.getGoldPrice();
  console.log(`✓ Returned in ${Date.now() - start}ms from cache`);
  
  // Simulate free API failure
  console.log('\nTest 3: Simulating free API down...');
  client.freeApiFailures = 3; // Force paid API usage
  await client.redisClient.del('gold_price'); // Clear cache
  
  price = await client.getGoldPrice();
  console.log(`✓ Failover worked! Source: ${price.source}`);
  
  console.log('\n📊 Final Stats:');
  console.log(client.getStats());
  
  process.exit(0);
}

testCascade();

node test-cascade.js