> ## Documentation Index
> Fetch the complete documentation index at: https://core.anylayer.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Usage

> Get detailed usage statistics for API keys

## Overview

Retrieve comprehensive usage statistics and analytics for your API keys. This endpoint provides detailed insights into API usage patterns, rate limit consumption, and performance metrics to help optimize your API key management.

<Tip>
  Use this endpoint to monitor API usage, identify optimization opportunities, and ensure you're staying within rate limits. The data helps with capacity planning and cost optimization.
</Tip>

## Parameters

<ParamField query="keyId" type="string">
  Specific API key ID to get usage for (optional)
</ParamField>

<ParamField query="timeframe" type="string">
  Time period for usage data

  * `1h` - Last hour
  * `24h` - Last 24 hours (default)
  * `7d` - Last 7 days
  * `30d` - Last 30 days
  * `90d` - Last 90 days
  * `1y` - Last year
  * `all` - All time
</ParamField>

<ParamField query="granularity" type="string">
  Data granularity for time series

  * `minute` - Per-minute data
  * `hour` - Per-hour data (default)
  * `day` - Per-day data
  * `week` - Per-week data
  * `month` - Per-month data
</ParamField>

<ParamField query="includeBreakdown" type="boolean">
  Include detailed breakdown by endpoint (default: true)
</ParamField>

<ParamField query="includeErrors" type="boolean">
  Include error statistics (default: true)
</ParamField>

<ParamField query="includeLatency" type="boolean">
  Include latency statistics (default: true)
</ParamField>

<ParamField query="sortBy" type="string">
  Sort results by field

  * `requests` - By request count (default)
  * `errors` - By error count
  * `latency` - By average latency
  * `timestamp` - By timestamp
</ParamField>

<ParamField query="sortOrder" type="string">
  Sort order

  * `desc` - Descending (default)
  * `asc` - Ascending
</ParamField>

<ParamField query="limit" type="number">
  Number of results to return (default: 100, max: 1000)
</ParamField>

<ParamField query="offset" type="number">
  Number of results to skip for pagination (default: 0)
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Indicates if the request was successful
</ResponseField>

<ResponseField name="usage" type="object">
  Usage statistics

  <Expandable title="usage properties">
    <ResponseField name="totalRequests" type="number">
      Total requests in the timeframe
    </ResponseField>

    <ResponseField name="successfulRequests" type="number">
      Number of successful requests
    </ResponseField>

    <ResponseField name="failedRequests" type="number">
      Number of failed requests
    </ResponseField>

    <ResponseField name="successRate" type="number">
      Success rate percentage (0-100)
    </ResponseField>

    <ResponseField name="averageLatency" type="number">
      Average response latency in milliseconds
    </ResponseField>

    <ResponseField name="peakLatency" type="number">
      Peak response latency in milliseconds
    </ResponseField>

    <ResponseField name="requestsPerMinute" type="number">
      Average requests per minute
    </ResponseField>

    <ResponseField name="requestsPerHour" type="number">
      Average requests per hour
    </ResponseField>

    <ResponseField name="requestsPerDay" type="number">
      Average requests per day
    </ResponseField>

    <ResponseField name="peakRequestsPerMinute" type="number">
      Peak requests per minute
    </ResponseField>

    <ResponseField name="peakRequestsPerHour" type="number">
      Peak requests per hour
    </ResponseField>

    <ResponseField name="dataTransferred" type="number">
      Total data transferred in bytes
    </ResponseField>

    <ResponseField name="averageDataPerRequest" type="number">
      Average data per request in bytes
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="timeSeries" type="array">
  Time series data points

  <Expandable title="timeSeries properties">
    <ResponseField name="timestamp" type="string">
      ISO 8601 timestamp of the data point
    </ResponseField>

    <ResponseField name="requests" type="number">
      Number of requests in this period
    </ResponseField>

    <ResponseField name="successfulRequests" type="number">
      Number of successful requests
    </ResponseField>

    <ResponseField name="failedRequests" type="number">
      Number of failed requests
    </ResponseField>

    <ResponseField name="averageLatency" type="number">
      Average latency in this period
    </ResponseField>

    <ResponseField name="peakLatency" type="number">
      Peak latency in this period
    </ResponseField>

    <ResponseField name="dataTransferred" type="number">
      Data transferred in this period
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="breakdown" type="object">
  Breakdown by endpoint

  <Expandable title="breakdown properties">
    <ResponseField name="byEndpoint" type="array">
      Usage by endpoint

      <Expandable title="endpoint properties">
        <ResponseField name="endpoint" type="string">
          API endpoint
        </ResponseField>

        <ResponseField name="requests" type="number">
          Number of requests
        </ResponseField>

        <ResponseField name="successRate" type="number">
          Success rate percentage
        </ResponseField>

        <ResponseField name="averageLatency" type="number">
          Average latency
        </ResponseField>

        <ResponseField name="dataTransferred" type="number">
          Data transferred
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="byMethod" type="array">
      Usage by HTTP method
    </ResponseField>

    <ResponseField name="byStatusCode" type="array">
      Usage by status code
    </ResponseField>

    <ResponseField name="byKey" type="array">
      Usage by API key
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="errors" type="object">
  Error statistics

  <Expandable title="errors properties">
    <ResponseField name="totalErrors" type="number">
      Total number of errors
    </ResponseField>

    <ResponseField name="errorRate" type="number">
      Error rate percentage
    </ResponseField>

    <ResponseField name="byType" type="array">
      Errors by type

      <Expandable title="error type properties">
        <ResponseField name="type" type="string">
          Error type
        </ResponseField>

        <ResponseField name="count" type="number">
          Number of errors
        </ResponseField>

        <ResponseField name="percentage" type="number">
          Percentage of total errors
        </ResponseField>

        <ResponseField name="description" type="string">
          Error description
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="byEndpoint" type="array">
      Errors by endpoint
    </ResponseField>

    <ResponseField name="byStatusCode" type="array">
      Errors by status code
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="rateLimits" type="object">
  Rate limit information

  <Expandable title="rateLimits properties">
    <ResponseField name="current" type="object">
      Current rate limits

      <Expandable title="current properties">
        <ResponseField name="requestsPerMinute" type="number">
          Requests per minute limit
        </ResponseField>

        <ResponseField name="requestsPerHour" type="number">
          Requests per hour limit
        </ResponseField>

        <ResponseField name="requestsPerDay" type="number">
          Requests per day limit
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="usage" type="object">
      Current usage against limits

      <Expandable title="usage properties">
        <ResponseField name="requestsPerMinute" type="number">
          Current requests per minute
        </ResponseField>

        <ResponseField name="requestsPerHour" type="number">
          Current requests per hour
        </ResponseField>

        <ResponseField name="requestsPerDay" type="number">
          Current requests per day
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="utilization" type="object">
      Rate limit utilization percentages

      <Expandable title="utilization properties">
        <ResponseField name="requestsPerMinute" type="number">
          Per-minute utilization percentage
        </ResponseField>

        <ResponseField name="requestsPerHour" type="number">
          Per-hour utilization percentage
        </ResponseField>

        <ResponseField name="requestsPerDay" type="number">
          Per-day utilization percentage
        </ResponseField>
      </Expandable>
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="alerts" type="array">
  Usage alerts and recommendations

  <Expandable title="alert properties">
    <ResponseField name="type" type="string">
      Alert type
    </ResponseField>

    <ResponseField name="message" type="string">
      Alert message
    </ResponseField>

    <ResponseField name="priority" type="string">
      Alert priority (high, medium, low)
    </ResponseField>

    <ResponseField name="recommendation" type="string">
      Recommended action
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="pagination" type="object">
  Pagination information

  <Expandable title="pagination properties">
    <ResponseField name="total" type="number">
      Total number of data points
    </ResponseField>

    <ResponseField name="limit" type="number">
      Number of data points returned
    </ResponseField>

    <ResponseField name="offset" type="number">
      Current offset
    </ResponseField>

    <ResponseField name="hasMore" type="boolean">
      Whether more data is available
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="timestamp" type="string">
  ISO 8601 timestamp of the response
</ResponseField>

## Examples

<CodeGroup>
  ```bash cURL (All Usage) theme={null}
  curl "https://api.onzks.com/v1/developer/usage" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```bash cURL (Specific Key) theme={null}
  curl "https://api.onzks.com/v1/developer/usage?keyId=key_1234567890abcdef" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```bash cURL (Last 7 Days) theme={null}
  curl "https://api.onzks.com/v1/developer/usage?timeframe=7d&granularity=day" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```bash cURL (With Breakdown) theme={null}
  curl "https://api.onzks.com/v1/developer/usage?includeBreakdown=true&includeErrors=true" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```bash cURL (Hourly Data) theme={null}
  curl "https://api.onzks.com/v1/developer/usage?granularity=hour&limit=24" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```javascript JavaScript theme={null}
  async function getUsage(options = {}) {
    const {
      keyId,
      timeframe = '24h',
      granularity = 'hour',
      includeBreakdown = true,
      includeErrors = true,
      includeLatency = true,
      sortBy = 'requests',
      sortOrder = 'desc',
      limit = 100,
      offset = 0
    } = options;

    const params = new URLSearchParams({
      timeframe,
      granularity,
      includeBreakdown: includeBreakdown.toString(),
      includeErrors: includeErrors.toString(),
      includeLatency: includeLatency.toString(),
      sortBy,
      sortOrder,
      limit: limit.toString(),
      offset: offset.toString()
    });

    if (keyId) params.append('keyId', keyId);

    const response = await fetch(
      `https://api.onzks.com/v1/developer/usage?${params}`,
      {
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY'
        }
      }
    );

    const data = await response.json();

    console.log(`Usage Statistics (${timeframe}):`);
    console.log(`Total Requests: ${data.usage.totalRequests}`);
    console.log(`Success Rate: ${data.usage.successRate}%`);
    console.log(`Average Latency: ${data.usage.averageLatency}ms`);
    console.log(`Peak Requests/Min: ${data.usage.peakRequestsPerMinute}`);

    if (data.alerts && data.alerts.length > 0) {
      console.log('Alerts:');
      data.alerts.forEach(alert => {
        console.log(`- ${alert.message} (${alert.priority} priority)`);
      });
    }

    return data;
  }

  // Usage examples
  await getUsage();
  await getUsage({ keyId: 'key_1234567890abcdef' });
  await getUsage({ timeframe: '7d', granularity: 'day' });
  await getUsage({ includeBreakdown: true, includeErrors: true });
  await getUsage({ granularity: 'hour', limit: 24 });
  ```

  ```python Python theme={null}
  import requests

  def get_usage(key_id=None, timeframe='24h', granularity='hour', include_breakdown=True,
                include_errors=True, include_latency=True, sort_by='requests', sort_order='desc',
                limit=100, offset=0):
      params = {
          'timeframe': timeframe,
          'granularity': granularity,
          'includeBreakdown': include_breakdown,
          'includeErrors': include_errors,
          'includeLatency': include_latency,
          'sortBy': sort_by,
          'sortOrder': sort_order,
          'limit': limit,
          'offset': offset
      }
      
      if key_id:
          params['keyId'] = key_id
      
      response = requests.get(
          'https://api.onzks.com/v1/developer/usage',
          headers={'Authorization': 'Bearer YOUR_API_KEY'},
          params=params
      )
      
      data = response.json()
      
      print(f"Usage Statistics ({timeframe}):")
      print(f"Total Requests: {data['usage']['totalRequests']}")
      print(f"Success Rate: {data['usage']['successRate']}%")
      print(f"Average Latency: {data['usage']['averageLatency']}ms")
      print(f"Peak Requests/Min: {data['usage']['peakRequestsPerMinute']}")
      
      if data.get('alerts'):
          print('Alerts:')
          for alert in data['alerts']:
              print(f"- {alert['message']} ({alert['priority']} priority)")
      
      return data

  # Usage examples
  get_usage()
  get_usage(key_id='key_1234567890abcdef')
  get_usage(timeframe='7d', granularity='day')
  get_usage(include_breakdown=True, include_errors=True)
  get_usage(granularity='hour', limit=24)
  ```
</CodeGroup>

## Response Example

```json theme={null}
{
  "success": true,
  "usage": {
    "totalRequests": 15420,
    "successfulRequests": 15080,
    "failedRequests": 340,
    "successRate": 97.8,
    "averageLatency": 245.5,
    "peakLatency": 1250.0,
    "requestsPerMinute": 10.7,
    "requestsPerHour": 642.5,
    "requestsPerDay": 15420,
    "peakRequestsPerMinute": 25,
    "peakRequestsPerHour": 1200,
    "dataTransferred": 125000000,
    "averageDataPerRequest": 8104
  },
  "timeSeries": [
    {
      "timestamp": "2024-01-20T14:00:00Z",
      "requests": 15,
      "successfulRequests": 14,
      "failedRequests": 1,
      "averageLatency": 230.5,
      "peakLatency": 450.0,
      "dataTransferred": 125000
    },
    {
      "timestamp": "2024-01-20T15:00:00Z",
      "requests": 18,
      "successfulRequests": 18,
      "failedRequests": 0,
      "averageLatency": 245.0,
      "peakLatency": 380.0,
      "dataTransferred": 150000
    }
  ],
  "breakdown": {
    "byEndpoint": [
      {
        "endpoint": "/v1/scores/:identity",
        "requests": 8500,
        "successRate": 98.5,
        "averageLatency": 180.0,
        "dataTransferred": 68000000
      },
      {
        "endpoint": "/v1/identity/:identity",
        "requests": 4200,
        "successRate": 97.2,
        "averageLatency": 320.0,
        "dataTransferred": 42000000
      },
      {
        "endpoint": "/v1/achievements/:identity",
        "requests": 2720,
        "successRate": 96.8,
        "averageLatency": 450.0,
        "dataTransferred": 15000000
      }
    ],
    "byMethod": [
      {
        "method": "GET",
        "requests": 14200,
        "percentage": 92.1
      },
      {
        "method": "POST",
        "requests": 1220,
        "percentage": 7.9
      }
    ],
    "byStatusCode": [
      {
        "statusCode": 200,
        "requests": 15080,
        "percentage": 97.8
      },
      {
        "statusCode": 429,
        "requests": 200,
        "percentage": 1.3
      },
      {
        "statusCode": 500,
        "requests": 140,
        "percentage": 0.9
      }
    ],
    "byKey": [
      {
        "keyId": "key_1234567890abcdef",
        "requests": 12000,
        "percentage": 77.8
      },
      {
        "keyId": "key_abcdef1234567890",
        "requests": 3420,
        "percentage": 22.2
      }
    ]
  },
  "errors": {
    "totalErrors": 340,
    "errorRate": 2.2,
    "byType": [
      {
        "type": "rate_limit_exceeded",
        "count": 200,
        "percentage": 58.8,
        "description": "Rate limit exceeded"
      },
      {
        "type": "server_error",
        "count": 140,
        "percentage": 41.2,
        "description": "Internal server error"
      }
    ],
    "byEndpoint": [
      {
        "endpoint": "/v1/scores/:identity",
        "errors": 120,
        "percentage": 35.3
      },
      {
        "endpoint": "/v1/identity/:identity",
        "errors": 220,
        "percentage": 64.7
      }
    ],
    "byStatusCode": [
      {
        "statusCode": 429,
        "count": 200,
        "percentage": 58.8
      },
      {
        "statusCode": 500,
        "count": 140,
        "percentage": 41.2
      }
    ]
  },
  "rateLimits": {
    "current": {
      "requestsPerMinute": 100,
      "requestsPerHour": 1000,
      "requestsPerDay": 10000
    },
    "usage": {
      "requestsPerMinute": 10.7,
      "requestsPerHour": 642.5,
      "requestsPerDay": 15420
    },
    "utilization": {
      "requestsPerMinute": 10.7,
      "requestsPerHour": 64.25,
      "requestsPerDay": 154.2
    }
  },
  "alerts": [
    {
      "type": "rate_limit_approaching",
      "message": "Daily rate limit is 154.2% utilized",
      "priority": "high",
      "recommendation": "Consider upgrading your plan or optimizing requests"
    },
    {
      "type": "error_rate_high",
      "message": "Error rate is 2.2%, above recommended 1%",
      "priority": "medium",
      "recommendation": "Review error patterns and implement retry logic"
    }
  ],
  "pagination": {
    "total": 24,
    "limit": 100,
    "offset": 0,
    "hasMore": false
  },
  "timestamp": "2024-01-20T15:45:00Z"
}
```

## Use Cases

### 1. Usage Monitoring Dashboard

Create a comprehensive usage dashboard:

```javascript theme={null}
function createUsageDashboard(usageData) {
  const dashboard = {
    overview: {
      totalRequests: usageData.usage.totalRequests,
      successRate: usageData.usage.successRate,
      averageLatency: usageData.usage.averageLatency,
      peakRequests: usageData.usage.peakRequestsPerMinute
    },
    trends: analyzeTrends(usageData.timeSeries),
    alerts: usageData.alerts,
    recommendations: generateRecommendations(usageData)
  };
  
  return dashboard;
}

function analyzeTrends(timeSeries) {
  const trends = {
    requests: calculateTrend(timeSeries.map(t => t.requests)),
    latency: calculateTrend(timeSeries.map(t => t.averageLatency)),
    errors: calculateTrend(timeSeries.map(t => t.failedRequests))
  };
  
  return trends;
}

function calculateTrend(values) {
  if (values.length < 2) return 'stable';
  
  const firstHalf = values.slice(0, Math.floor(values.length / 2));
  const secondHalf = values.slice(Math.floor(values.length / 2));
  
  const firstAvg = firstHalf.reduce((sum, val) => sum + val, 0) / firstHalf.length;
  const secondAvg = secondHalf.reduce((sum, val) => sum + val, 0) / secondHalf.length;
  
  const change = (secondAvg - firstAvg) / firstAvg;
  
  if (change > 0.1) return 'increasing';
  if (change < -0.1) return 'decreasing';
  return 'stable';
}
```

### 2. Performance Optimization

Optimize API usage based on data:

```javascript theme={null}
function optimizeUsage(usageData) {
  const optimization = {
    bottlenecks: identifyBottlenecks(usageData),
    recommendations: generateOptimizationRecommendations(usageData),
    costSavings: calculateCostSavings(usageData)
  };
  
  return optimization;
}

function identifyBottlenecks(usageData) {
  const bottlenecks = [];
  
  // High latency endpoints
  usageData.breakdown.byEndpoint.forEach(endpoint => {
    if (endpoint.averageLatency > 500) {
      bottlenecks.push({
        type: 'high_latency',
        endpoint: endpoint.endpoint,
        latency: endpoint.averageLatency,
        recommendation: 'Consider caching or optimizing this endpoint'
      });
    }
  });
  
  // High error rate endpoints
  usageData.breakdown.byEndpoint.forEach(endpoint => {
    if (endpoint.successRate < 95) {
      bottlenecks.push({
        type: 'high_error_rate',
        endpoint: endpoint.endpoint,
        successRate: endpoint.successRate,
        recommendation: 'Investigate and fix errors in this endpoint'
      });
    }
  });
  
  // Rate limit issues
  if (usageData.rateLimits.utilization.requestsPerDay > 80) {
    bottlenecks.push({
      type: 'rate_limit_approaching',
      utilization: usageData.rateLimits.utilization.requestsPerDay,
      recommendation: 'Consider upgrading your plan or optimizing requests'
    });
  }
  
  return bottlenecks;
}
```

### 3. Cost Analysis

Analyze API usage costs:

```javascript theme={null}
function analyzeCosts(usageData) {
  const costs = {
    current: calculateCurrentCosts(usageData),
    projected: calculateProjectedCosts(usageData),
    optimization: calculateOptimizationSavings(usageData)
  };
  
  return costs;
}

function calculateCurrentCosts(usageData) {
  const requests = usageData.usage.totalRequests;
  const dataTransferred = usageData.usage.dataTransferred;
  
  // Example pricing (adjust based on actual pricing)
  const requestCost = requests * 0.001; // $0.001 per request
  const dataCost = dataTransferred * 0.000001; // $0.000001 per byte
  
  return {
    requests: requestCost,
    data: dataCost,
    total: requestCost + dataCost
  };
}

function calculateProjectedCosts(usageData) {
  const current = calculateCurrentCosts(usageData);
  const growthRate = calculateGrowthRate(usageData.timeSeries);
  
  return {
    nextMonth: current.total * (1 + growthRate),
    nextQuarter: current.total * Math.pow(1 + growthRate, 3),
    nextYear: current.total * Math.pow(1 + growthRate, 12)
  };
}
```

### 4. Alert Management

Manage usage alerts:

```javascript theme={null}
function manageAlerts(usageData) {
  const alerts = [];
  
  // Rate limit alerts
  if (usageData.rateLimits.utilization.requestsPerDay > 90) {
    alerts.push({
      type: 'critical',
      message: 'Daily rate limit exceeded',
      action: 'upgrade_plan'
    });
  } else if (usageData.rateLimits.utilization.requestsPerDay > 80) {
    alerts.push({
      type: 'warning',
      message: 'Daily rate limit approaching',
      action: 'monitor_usage'
    });
  }
  
  // Error rate alerts
  if (usageData.usage.successRate < 95) {
    alerts.push({
      type: 'warning',
      message: 'High error rate detected',
      action: 'investigate_errors'
    });
  }
  
  // Latency alerts
  if (usageData.usage.averageLatency > 1000) {
    alerts.push({
      type: 'warning',
      message: 'High latency detected',
      action: 'optimize_requests'
    });
  }
  
  return alerts;
}
```

### 5. Capacity Planning

Plan for future capacity needs:

```javascript theme={null}
function planCapacity(usageData) {
  const plan = {
    current: {
      requests: usageData.usage.totalRequests,
      latency: usageData.usage.averageLatency,
      errors: usageData.usage.failedRequests
    },
    projected: {
      requests: projectRequests(usageData.timeSeries),
      latency: projectLatency(usageData.timeSeries),
      errors: projectErrors(usageData.timeSeries)
    },
    recommendations: generateCapacityRecommendations(usageData)
  };
  
  return plan;
}

function projectRequests(timeSeries) {
  if (timeSeries.length < 2) return timeSeries[0]?.requests || 0;
  
  const requests = timeSeries.map(t => t.requests);
  const trend = calculateTrend(requests);
  
  if (trend === 'increasing') {
    const growthRate = (requests[requests.length - 1] - requests[0]) / requests[0];
    return Math.ceil(requests[requests.length - 1] * (1 + growthRate));
  }
  
  return requests[requests.length - 1];
}
```

## Best Practices

### 1. Regular Monitoring

Monitor usage regularly:

```javascript theme={null}
async function monitorUsage() {
  const usage = await getUsage({ timeframe: '24h' });
  
  const monitoring = {
    alerts: usage.alerts,
    recommendations: generateRecommendations(usage),
    trends: analyzeTrends(usage.timeSeries)
  };
  
  return monitoring;
}
```

### 2. Automated Alerts

Set up automated alerts:

```javascript theme={null}
function setupUsageAlerts(usageData) {
  const alerts = [];
  
  // Rate limit alerts
  if (usageData.rateLimits.utilization.requestsPerDay > 80) {
    alerts.push({
      type: 'rate_limit',
      message: 'Rate limit utilization is high',
      threshold: 80,
      current: usageData.rateLimits.utilization.requestsPerDay
    });
  }
  
  // Error rate alerts
  if (usageData.usage.successRate < 95) {
    alerts.push({
      type: 'error_rate',
      message: 'Success rate is below 95%',
      threshold: 95,
      current: usageData.usage.successRate
    });
  }
  
  // Latency alerts
  if (usageData.usage.averageLatency > 500) {
    alerts.push({
      type: 'latency',
      message: 'Average latency is high',
      threshold: 500,
      current: usageData.usage.averageLatency
    });
  }
  
  return alerts;
}
```

### 3. Performance Optimization

Optimize based on usage data:

```javascript theme={null}
function optimizePerformance(usageData) {
  const optimization = {
    caching: identifyCachingOpportunities(usageData),
    batching: identifyBatchingOpportunities(usageData),
    rateLimiting: optimizeRateLimiting(usageData)
  };
  
  return optimization;
}
```

### 4. Cost Optimization

Optimize costs:

```javascript theme={null}
function optimizeCosts(usageData) {
  const optimization = {
    requestOptimization: optimizeRequests(usageData),
    dataOptimization: optimizeDataTransfer(usageData),
    planOptimization: optimizePlan(usageData)
  };
  
  return optimization;
}
```

## Related Endpoints

* [List API Keys](/api-reference/developer/list-api-keys) - View all API keys
* [Create API Key](/api-reference/developer/create-api-key) - Create new API keys
* [Revoke API Key](/api-reference/developer/revoke-api-key) - Revoke API keys

## Troubleshooting

### "No usage data found"

**Cause**: No usage data for the specified timeframe or key.

**Solution**:

* Check if the API key has been used
* Try a longer timeframe
* Verify the key ID is correct

### "Invalid timeframe"

**Cause**: Unsupported timeframe value.

**Solution**:

* Use supported timeframes: 1h, 24h, 7d, 30d, 90d, 1y, all
* Check for typos

### "Invalid granularity"

**Cause**: Unsupported granularity value.

**Solution**:

* Use supported granularities: minute, hour, day, week, month
* Check for typos

## Rate Limits

Usage requests are subject to rate limits:

* **Free tier**: 60 requests per minute
* **Starter tier**: 300 requests per minute
* **Professional tier**: 1,000 requests per minute
* **Enterprise tier**: Custom limits

Implement caching to reduce API calls.