X-Shim-Usage: 1050
X-Shim-Limit: 1000
X-Shim-Usage-Percentage: 105.0
X-Shim-Overage: soft

X-Shim-Usage: 1200
X-Shim-Limit: 1000
X-Shim-Usage-Percentage: 120.0
X-Shim-Overage: throttled

X-Shim-Usage: 1600
X-Shim-Limit: 1000
X-Shim-Usage-Percentage: 160.0
X-Shim-Overage: limp

X-Shim-Usage: 1050000
X-Shim-Limit: 1000000
X-Shim-Usage-Percentage: 105.0
X-Shim-Overage: soft

X-Shim-Usage: 1250000
X-Shim-Limit: 1000000
X-Shim-Usage-Percentage: 125.0
X-Shim-Overage: billing

Base limit: 1,000,000
Grace threshold (110%): 1,100,000
Current usage: 1,250,000
Overage: 1,250,000 - 1,100,000 = 150,000 repairs
Billed units: 150,000 / 1,000 = 150 units
Cost: 150 × $0.30 = $45

X-RateLimit-Limit: 100          # Requests allowed this minute
X-RateLimit-Remaining: 87       # Requests remaining this minute
X-RateLimit-Reset: 1706000060   # Unix timestamp when window resets

X-Shim-Usage: 1200              # Repairs used this month (integer)
X-Shim-Limit: 1000              # Monthly limit for your tier
X-Shim-Usage-Percentage: 120.0  # Usage as percentage of limit

X-Shim-Overage: soft            # 100-110% grace period
X-Shim-Overage: throttled       # Free/Pro 110-150%
X-Shim-Overage: limp            # Free/Pro 150%+
X-Shim-Overage: billing         # Team 110%+ (metered)

const response = await fetch('https://api.shim.so/v1/repair', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${apiKey}` },
  body: JSON.stringify({ raw_output })
});

const usage = response.headers.get('X-Shim-Usage');
const limit = response.headers.get('X-Shim-Limit');
const percentage = response.headers.get('X-Shim-Usage-Percentage');
const overage = response.headers.get('X-Shim-Overage');

console.log(`Usage: ${usage}/${limit} (${percentage}%)`);
console.log(`Overage phase: ${overage ?? 'normal'}`);

async function repairWithBackoff(input: string, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const response = await shim.repair({ raw_output: input });

    if (response.success) {
      return response.repaired;
    }

    // Check if rate limited
    const error = response.metadata.errors[0];
    if (error?.code === 'RATE_LIMIT_EXCEEDED') {
      const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
      await new Promise(r => setTimeout(r, delay));
      continue;
    }

    throw new Error('Repair failed');
  }

  throw new Error('Max retries exceeded');
}

const response = await fetch('https://api.shim.so/v1/repair', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${apiKey}` },
  body: JSON.stringify({ raw_output: input })
});

const percentage = parseFloat(response.headers.get('X-Shim-Usage-Percentage') || '0');

if (percentage > 90) {
  console.warn(`High usage: ${percentage}% of monthly limit`);
  // Send alert
}

# Upgrade in console
https://console.shim.so → "Upgrade to Pro"

# Upgrade in console
https://console.shim.so → "Upgrade to Team"

const usage = response.headers.get('X-Shim-Usage');
logToMonitoring('shim.usage', usage);

const cache = new Map();

async function cachedRepair(input: string) {
  if (cache.has(input)) {
    return cache.get(input);
  }

  const result = await shim.repair({ raw_output: input });
  cache.set(input, result);
  return result;
}

// Instead of one large batch request
const { session_id } = await shim.stream.start();

for await (const chunk of llmStream) {
  await shim.stream.push({ session_id, chunk });
}

const result = await shim.stream.finalize({ session_id });

if (percentage >= 80 && percentage < 100) {
  sendAlert('Warning: 80% of monthly limit reached');
}

if (percentage >= 100) {
  sendAlert('Critical: Monthly limit exceeded, throttling active');
}