> ## 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.

# List API Keys

> Get all API keys for your account

## Overview

Retrieve all API keys associated with your account. This endpoint provides comprehensive information about your API keys including their status, permissions, usage statistics, and configuration details.

<Tip>
  Use this endpoint to monitor your API keys, check their status, and manage your API key inventory. The actual API key values are masked for security.
</Tip>

## Parameters

<ParamField query="status" type="string">
  Filter by API key status

  * `active` - Active API keys (default)
  * `inactive` - Inactive API keys
  * `expired` - Expired API keys
  * `revoked` - Revoked API keys
  * `all` - All API keys regardless of status
</ParamField>

<ParamField query="permission" type="string">
  Filter by permission resource

  * `identity` - Identity management keys
  * `scores` - Score query keys
  * `achievements` - Achievement keys
  * `trading` - Trading data keys
  * `trust` - Trust layer keys
  * `attestations` - Attestation keys
  * `all` - All permissions
</ParamField>

<ParamField query="search" type="string">
  Search by API key name or description
</ParamField>

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

  * `createdAt` - By creation date (default)
  * `lastUsed` - By last use date
  * `name` - By name
  * `usage` - By usage count
</ParamField>

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

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

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

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

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

<ParamField query="includeWebhooks" type="boolean">
  Include webhook configurations (default: true)
</ParamField>

## Response

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

<ResponseField name="keys" type="array">
  Array of API key objects

  <Expandable title="key properties">
    <ResponseField name="id" type="string">
      API key identifier
    </ResponseField>

    <ResponseField name="name" type="string">
      API key name
    </ResponseField>

    <ResponseField name="description" type="string">
      API key description
    </ResponseField>

    <ResponseField name="permissions" type="array">
      API key permissions

      <Expandable title="permission properties">
        <ResponseField name="resource" type="string">
          Resource type
        </ResponseField>

        <ResponseField name="actions" type="array">
          Allowed actions
        </ResponseField>

        <ResponseField name="restrictions" type="object">
          Permission restrictions
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="rateLimit" type="object">
      Rate limiting configuration

      <Expandable title="rateLimit 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>

        <ResponseField name="burstLimit" type="number">
          Burst limit
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="status" type="string">
      API key status (active, inactive, expired, revoked)
    </ResponseField>

    <ResponseField name="createdAt" type="string">
      ISO 8601 timestamp of creation
    </ResponseField>

    <ResponseField name="expiry" type="string">
      ISO 8601 timestamp of expiry (if set)
    </ResponseField>

    <ResponseField name="lastUsed" type="string">
      ISO 8601 timestamp of last use (null if never used)
    </ResponseField>

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

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

        <ResponseField name="requestsToday" type="number">
          Requests made today
        </ResponseField>

        <ResponseField name="requestsThisWeek" type="number">
          Requests made this week
        </ResponseField>

        <ResponseField name="requestsThisMonth" type="number">
          Requests made this month
        </ResponseField>

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

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

        <ResponseField name="lastRequestAt" type="string">
          ISO 8601 timestamp of last request
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="webhooks" type="array">
      Configured webhooks

      <Expandable title="webhook properties">
        <ResponseField name="id" type="string">
          Webhook identifier
        </ResponseField>

        <ResponseField name="url" type="string">
          Webhook URL
        </ResponseField>

        <ResponseField name="events" type="array">
          Subscribed events
        </ResponseField>

        <ResponseField name="status" type="string">
          Webhook status (active, inactive, failed)
        </ResponseField>

        <ResponseField name="lastDelivery" type="string">
          ISO 8601 timestamp of last delivery
        </ResponseField>

        <ResponseField name="deliveryCount" type="number">
          Total deliveries
        </ResponseField>

        <ResponseField name="failureCount" type="number">
          Total failures
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="metadata" type="object">
      Additional metadata
    </ResponseField>
  </Expandable>
</ResponseField>

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

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

    <ResponseField name="limit" type="number">
      Number of API keys returned
    </ResponseField>

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

    <ResponseField name="hasMore" type="boolean">
      Whether more API keys are available
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="summary" type="object">
  API key summary statistics

  <Expandable title="summary properties">
    <ResponseField name="totalKeys" type="number">
      Total number of API keys
    </ResponseField>

    <ResponseField name="activeKeys" type="number">
      Number of active API keys
    </ResponseField>

    <ResponseField name="inactiveKeys" type="number">
      Number of inactive API keys
    </ResponseField>

    <ResponseField name="expiredKeys" type="number">
      Number of expired API keys
    </ResponseField>

    <ResponseField name="revokedKeys" type="number">
      Number of revoked API keys
    </ResponseField>

    <ResponseField name="totalRequests" type="number">
      Total requests across all keys
    </ResponseField>

    <ResponseField name="requestsToday" type="number">
      Total requests today
    </ResponseField>

    <ResponseField name="averageRequestsPerKey" type="number">
      Average requests per key
    </ResponseField>
  </Expandable>
</ResponseField>

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

## Examples

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

  ```bash cURL (Active Keys Only) theme={null}
  curl "https://api.onzks.com/v1/developer/keys?status=active" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```bash cURL (Search by Name) theme={null}
  curl "https://api.onzks.com/v1/developer/keys?search=production" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```bash cURL (Sort by Usage) theme={null}
  curl "https://api.onzks.com/v1/developer/keys?sortBy=usage&sortOrder=desc" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```bash cURL (With Pagination) theme={null}
  curl "https://api.onzks.com/v1/developer/keys?limit=20&offset=40" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```javascript JavaScript theme={null}
  async function listApiKeys(options = {}) {
    const {
      status = 'active',
      permission,
      search,
      sortBy = 'createdAt',
      sortOrder = 'desc',
      limit = 50,
      offset = 0,
      includeUsage = true,
      includeWebhooks = true
    } = options;

    const params = new URLSearchParams({
      status,
      sortBy,
      sortOrder,
      limit: limit.toString(),
      offset: offset.toString(),
      includeUsage: includeUsage.toString(),
      includeWebhooks: includeWebhooks.toString()
    });

    if (permission) params.append('permission', permission);
    if (search) params.append('search', search);

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

    const data = await response.json();

    console.log(`API Keys (${data.summary.totalKeys} total):`);
    console.log(`Active: ${data.summary.activeKeys}`);
    console.log(`Total Requests: ${data.summary.totalRequests}`);
    console.log(`Requests Today: ${data.summary.requestsToday}`);

    data.keys.forEach(key => {
      console.log(`- ${key.name} (${key.status}) - ${key.usage.totalRequests} requests`);
    });

    return data;
  }

  // Usage examples
  await listApiKeys();
  await listApiKeys({ status: 'active' });
  await listApiKeys({ search: 'production' });
  await listApiKeys({ sortBy: 'usage', sortOrder: 'desc' });
  await listApiKeys({ limit: 20, offset: 40 });
  ```

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

  def list_api_keys(status='active', permission=None, search=None, sort_by='createdAt',
                   sort_order='desc', limit=50, offset=0, include_usage=True, include_webhooks=True):
      params = {
          'status': status,
          'sortBy': sort_by,
          'sortOrder': sort_order,
          'limit': limit,
          'offset': offset,
          'includeUsage': include_usage,
          'includeWebhooks': include_webhooks
      }
      
      if permission:
          params['permission'] = permission
      if search:
          params['search'] = search
      
      response = requests.get(
          'https://api.onzks.com/v1/developer/keys',
          headers={'Authorization': 'Bearer YOUR_API_KEY'},
          params=params
      )
      
      data = response.json()
      
      print(f"API Keys ({data['summary']['totalKeys']} total):")
      print(f"Active: {data['summary']['activeKeys']}")
      print(f"Total Requests: {data['summary']['totalRequests']}")
      print(f"Requests Today: {data['summary']['requestsToday']}")
      
      for key in data['keys']:
          print(f"- {key['name']} ({key['status']}) - {key['usage']['totalRequests']} requests")
      
      return data

  # Usage examples
  list_api_keys()
  list_api_keys(status='active')
  list_api_keys(search='production')
  list_api_keys(sort_by='usage', sort_order='desc')
  list_api_keys(limit=20, offset=40)
  ```
</CodeGroup>

## Response Example

```json theme={null}
{
  "success": true,
  "keys": [
    {
      "id": "key_1234567890abcdef",
      "name": "Production App",
      "description": "API key for production application",
      "permissions": [
        {
          "resource": "scores",
          "actions": ["read"],
          "restrictions": {}
        },
        {
          "resource": "identity",
          "actions": ["read"],
          "restrictions": {}
        }
      ],
      "rateLimit": {
        "requestsPerMinute": 100,
        "requestsPerHour": 1000,
        "requestsPerDay": 10000,
        "burstLimit": 150
      },
      "status": "active",
      "createdAt": "2024-01-15T10:30:00Z",
      "expiry": null,
      "lastUsed": "2024-01-20T14:30:00Z",
      "usage": {
        "totalRequests": 15420,
        "requestsToday": 1250,
        "requestsThisWeek": 8750,
        "requestsThisMonth": 15420,
        "averageRequestsPerDay": 1028,
        "peakRequestsPerHour": 150,
        "lastRequestAt": "2024-01-20T14:30:00Z"
      },
      "webhooks": [
        {
          "id": "webhook_1234567890abcdef",
          "url": "https://myapp.com/webhooks/zkscore",
          "events": ["score.updated", "achievement.earned"],
          "status": "active",
          "lastDelivery": "2024-01-20T14:25:00Z",
          "deliveryCount": 1250,
          "failureCount": 5
        }
      ],
      "metadata": {
        "environment": "production",
        "version": "1.0.0"
      }
    },
    {
      "id": "key_abcdef1234567890",
      "name": "Development Testing",
      "description": "API key for development testing",
      "permissions": [
        {
          "resource": "all",
          "actions": ["all"],
          "restrictions": {}
        }
      ],
      "rateLimit": {
        "requestsPerMinute": 50,
        "requestsPerHour": 500,
        "requestsPerDay": 5000,
        "burstLimit": 75
      },
      "status": "active",
      "createdAt": "2024-01-10T09:15:00Z",
      "expiry": "2024-04-10T09:15:00Z",
      "lastUsed": "2024-01-19T16:45:00Z",
      "usage": {
        "totalRequests": 3250,
        "requestsToday": 150,
        "requestsThisWeek": 1050,
        "requestsThisMonth": 3250,
        "averageRequestsPerDay": 325,
        "peakRequestsPerHour": 25,
        "lastRequestAt": "2024-01-19T16:45:00Z"
      },
      "webhooks": [],
      "metadata": {
        "environment": "development",
        "version": "0.9.0"
      }
    }
  ],
  "pagination": {
    "total": 5,
    "limit": 50,
    "offset": 0,
    "hasMore": false
  },
  "summary": {
    "totalKeys": 5,
    "activeKeys": 4,
    "inactiveKeys": 0,
    "expiredKeys": 0,
    "revokedKeys": 1,
    "totalRequests": 18670,
    "requestsToday": 1400,
    "averageRequestsPerKey": 3734
  },
  "timestamp": "2024-01-20T15:45:00Z"
}
```

## Use Cases

### 1. API Key Management Dashboard

Create a comprehensive management dashboard:

```javascript theme={null}
function createApiKeyDashboard(keys) {
  const dashboard = {
    overview: {
      total: keys.length,
      active: keys.filter(k => k.status === 'active').length,
      expired: keys.filter(k => k.status === 'expired').length,
      revoked: keys.filter(k => k.status === 'revoked').length
    },
    usage: {
      totalRequests: keys.reduce((sum, k) => sum + k.usage.totalRequests, 0),
      requestsToday: keys.reduce((sum, k) => sum + k.usage.requestsToday, 0),
      averagePerKey: keys.reduce((sum, k) => sum + k.usage.averageRequestsPerDay, 0) / keys.length
    },
    alerts: generateAlerts(keys),
    recommendations: generateRecommendations(keys)
  };
  
  return dashboard;
}

function generateAlerts(keys) {
  const alerts = [];
  
  keys.forEach(key => {
    if (key.status === 'expired') {
      alerts.push({
        type: 'expired',
        message: `API key "${key.name}" has expired`,
        keyId: key.id
      });
    }
    
    if (key.usage.requestsToday > key.rateLimit.requestsPerDay * 0.9) {
      alerts.push({
        type: 'rate_limit',
        message: `API key "${key.name}" is approaching daily limit`,
        keyId: key.id
      });
    }
    
    if (key.lastUsed && Date.now() - new Date(key.lastUsed) > 30 * 24 * 60 * 60 * 1000) {
      alerts.push({
        type: 'unused',
        message: `API key "${key.name}" has not been used in 30 days`,
        keyId: key.id
      });
    }
  });
  
  return alerts;
}
```

### 2. Usage Analytics

Analyze API key usage patterns:

```javascript theme={null}
function analyzeUsage(keys) {
  const analysis = {
    byKey: keys.map(key => ({
      id: key.id,
      name: key.name,
      usage: key.usage,
      efficiency: key.usage.totalRequests / key.rateLimit.requestsPerDay,
      trend: calculateTrend(key.usage)
    })),
    overall: {
      totalRequests: keys.reduce((sum, k) => sum + k.usage.totalRequests, 0),
      averageEfficiency: keys.reduce((sum, k) => sum + (k.usage.totalRequests / k.rateLimit.requestsPerDay), 0) / keys.length,
      peakUsage: Math.max(...keys.map(k => k.usage.peakRequestsPerHour))
    },
    recommendations: generateUsageRecommendations(keys)
  };
  
  return analysis;
}

function calculateTrend(usage) {
  const today = usage.requestsToday;
  const thisWeek = usage.requestsThisWeek;
  const thisMonth = usage.requestsThisMonth;
  
  const weeklyAverage = thisWeek / 7;
  const monthlyAverage = thisMonth / 30;
  
  if (today > weeklyAverage * 1.2) return 'increasing';
  if (today < weeklyAverage * 0.8) return 'decreasing';
  return 'stable';
}
```

### 3. Permission Analysis

Analyze API key permissions:

```javascript theme={null}
function analyzePermissions(keys) {
  const permissionStats = {};
  
  keys.forEach(key => {
    key.permissions.forEach(permission => {
      if (!permissionStats[permission.resource]) {
        permissionStats[permission.resource] = {
          count: 0,
          actions: new Set(),
          keys: []
        };
      }
      
      permissionStats[permission.resource].count++;
      permission.actions.forEach(action => {
        permissionStats[permission.resource].actions.add(action);
      });
      permissionStats[permission.resource].keys.push(key.id);
    });
  });
  
  return {
    byResource: Object.entries(permissionStats).map(([resource, stats]) => ({
      resource,
      count: stats.count,
      actions: Array.from(stats.actions),
      keys: stats.keys
    })),
    recommendations: generatePermissionRecommendations(permissionStats)
  };
}
```

### 4. Webhook Monitoring

Monitor webhook configurations:

```javascript theme={null}
function monitorWebhooks(keys) {
  const webhookStats = {
    total: 0,
    active: 0,
    failed: 0,
    byStatus: {},
    byEvent: {},
    recommendations: []
  };
  
  keys.forEach(key => {
    key.webhooks.forEach(webhook => {
      webhookStats.total++;
      webhookStats.byStatus[webhook.status] = (webhookStats.byStatus[webhook.status] || 0) + 1;
      
      if (webhook.status === 'active') webhookStats.active++;
      if (webhook.status === 'failed') webhookStats.failed++;
      
      webhook.events.forEach(event => {
        webhookStats.byEvent[event] = (webhookStats.byEvent[event] || 0) + 1;
      });
      
      // Check for webhook issues
      if (webhook.failureCount > webhook.deliveryCount * 0.1) {
        webhookStats.recommendations.push({
          type: 'high_failure_rate',
          message: `Webhook for ${key.name} has high failure rate`,
          webhookId: webhook.id,
          failureRate: webhook.failureCount / webhook.deliveryCount
        });
      }
    });
  });
  
  return webhookStats;
}
```

### 5. Key Rotation Planning

Plan API key rotations:

```javascript theme={null}
function planKeyRotations(keys) {
  const rotations = [];
  
  keys.forEach(key => {
    const daysUntilExpiry = key.expiry ? 
      Math.ceil((new Date(key.expiry) - new Date()) / (1000 * 60 * 60 * 24)) : null;
    
    if (daysUntilExpiry && daysUntilExpiry < 30) {
      rotations.push({
        keyId: key.id,
        name: key.name,
        type: 'expiry',
        urgency: daysUntilExpiry < 7 ? 'high' : 'medium',
        daysUntilExpiry,
        recommendation: 'Rotate key before expiry'
      });
    }
    
    if (key.usage.totalRequests > key.rateLimit.requestsPerDay * 0.8) {
      rotations.push({
        keyId: key.id,
        name: key.name,
        type: 'usage',
        urgency: 'medium',
        usage: key.usage.totalRequests,
        recommendation: 'Consider upgrading rate limits or rotating key'
      });
    }
    
    if (key.lastUsed && Date.now() - new Date(key.lastUsed) > 90 * 24 * 60 * 60 * 1000) {
      rotations.push({
        keyId: key.id,
        name: key.name,
        type: 'unused',
        urgency: 'low',
        daysSinceLastUse: Math.ceil((Date.now() - new Date(key.lastUsed)) / (1000 * 60 * 60 * 24)),
        recommendation: 'Consider revoking unused key'
      });
    }
  });
  
  return rotations.sort((a, b) => {
    const urgencyOrder = { high: 3, medium: 2, low: 1 };
    return urgencyOrder[b.urgency] - urgencyOrder[a.urgency];
  });
}
```

## Best Practices

### 1. Regular Monitoring

Monitor API keys regularly:

```javascript theme={null}
async function monitorApiKeys() {
  const keys = await listApiKeys({ status: 'all' });
  
  const monitoring = {
    expired: keys.keys.filter(k => k.status === 'expired'),
    expiring: keys.keys.filter(k => k.expiry && new Date(k.expiry) < new Date(Date.now() + 30 * 24 * 60 * 60 * 1000)),
    unused: keys.keys.filter(k => k.lastUsed && Date.now() - new Date(k.lastUsed) > 30 * 24 * 60 * 60 * 1000),
    highUsage: keys.keys.filter(k => k.usage.requestsToday > k.rateLimit.requestsPerDay * 0.8)
  };
  
  return monitoring;
}
```

### 2. Automated Alerts

Set up automated alerts:

```javascript theme={null}
function setupAlerts(keys) {
  const alerts = [];
  
  keys.forEach(key => {
    // Expiry alerts
    if (key.expiry) {
      const daysUntilExpiry = Math.ceil((new Date(key.expiry) - new Date()) / (1000 * 60 * 60 * 24));
      if (daysUntilExpiry <= 7) {
        alerts.push({
          type: 'expiry_warning',
          keyId: key.id,
          message: `API key "${key.name}" expires in ${daysUntilExpiry} days`
        });
      }
    }
    
    // Usage alerts
    if (key.usage.requestsToday > key.rateLimit.requestsPerDay * 0.9) {
      alerts.push({
        type: 'usage_warning',
        keyId: key.id,
        message: `API key "${key.name}" is at 90% of daily limit`
      });
    }
    
    // Unused key alerts
    if (key.lastUsed && Date.now() - new Date(key.lastUsed) > 60 * 24 * 60 * 60 * 1000) {
      alerts.push({
        type: 'unused_warning',
        keyId: key.id,
        message: `API key "${key.name}" has not been used in 60 days`
      });
    }
  });
  
  return alerts;
}
```

### 3. Key Lifecycle Management

Manage key lifecycle:

```javascript theme={null}
async function manageKeyLifecycle() {
  const keys = await listApiKeys({ status: 'all' });
  
  const lifecycle = {
    active: keys.keys.filter(k => k.status === 'active'),
    expired: keys.keys.filter(k => k.status === 'expired'),
    revoked: keys.keys.filter(k => k.status === 'revoked'),
    needsRotation: keys.keys.filter(k => {
      if (k.expiry && new Date(k.expiry) < new Date(Date.now() + 30 * 24 * 60 * 60 * 1000)) {
        return true;
      }
      if (k.usage.totalRequests > k.rateLimit.requestsPerDay * 0.8) {
        return true;
      }
      return false;
    })
  };
  
  return lifecycle;
}
```

### 4. Usage Optimization

Optimize API key usage:

```javascript theme={null}
function optimizeUsage(keys) {
  const optimization = {
    underutilized: keys.filter(k => k.usage.totalRequests < k.rateLimit.requestsPerDay * 0.1),
    overutilized: keys.filter(k => k.usage.totalRequests > k.rateLimit.requestsPerDay * 0.8),
    recommendations: []
  };
  
  optimization.underutilized.forEach(key => {
    optimization.recommendations.push({
      type: 'reduce_limits',
      keyId: key.id,
      message: `Consider reducing rate limits for "${key.name}"`,
      currentLimit: key.rateLimit.requestsPerDay,
      suggestedLimit: Math.ceil(key.usage.totalRequests * 1.2)
    });
  });
  
  optimization.overutilized.forEach(key => {
    optimization.recommendations.push({
      type: 'increase_limits',
      keyId: key.id,
      message: `Consider increasing rate limits for "${key.name}"`,
      currentLimit: key.rateLimit.requestsPerDay,
      suggestedLimit: Math.ceil(key.usage.totalRequests * 1.5)
    });
  });
  
  return optimization;
}
```

## Related Endpoints

* [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
* [Get Usage](/api-reference/developer/get-usage) - View detailed usage statistics

## Troubleshooting

### "No API keys found"

**Cause**: No API keys match the criteria or account has no keys.

**Solution**:

* Remove restrictive filters
* Check if you have created any API keys
* Verify your account has API key creation permissions

### "Invalid status filter"

**Cause**: Unsupported status value.

**Solution**:

* Use supported statuses: active, inactive, expired, revoked, all
* Check for typos

### "Invalid permission filter"

**Cause**: Unsupported permission value.

**Solution**:

* Use supported permissions: identity, scores, achievements, trading, trust, attestations, all
* Check for typos

## Rate Limits

API key listing 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.