Get Usage

Get Usage

curl --request GET \
  --url https://api-mainnet.onzks.com/v1/developer/usage \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api-mainnet.onzks.com/v1/developer/usage', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api-mainnet.onzks.com/v1/developer/usage",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api-mainnet.onzks.com/v1/developer/usage"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api-mainnet.onzks.com/v1/developer/usage")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "success": true,
  "usage": {
    "totalRequests": 123,
    "successfulRequests": 123,
    "failedRequests": 123,
    "successRate": 123,
    "averageLatency": 123,
    "peakLatency": 123,
    "requestsPerMinute": 123,
    "requestsPerHour": 123,
    "requestsPerDay": 123,
    "peakRequestsPerMinute": 123,
    "peakRequestsPerHour": 123,
    "dataTransferred": 123,
    "averageDataPerRequest": 123
  },
  "timeSeries": [
    {
      "timestamp": "<string>",
      "requests": 123,
      "successfulRequests": 123,
      "failedRequests": 123,
      "averageLatency": 123,
      "peakLatency": 123,
      "dataTransferred": 123
    }
  ],
  "breakdown": {
    "byEndpoint": [
      {
        "endpoint": "<string>",
        "requests": 123,
        "successRate": 123,
        "averageLatency": 123,
        "dataTransferred": 123
      }
    ],
    "byMethod": [
      {}
    ],
    "byStatusCode": [
      {}
    ],
    "byKey": [
      {}
    ]
  },
  "errors": {
    "totalErrors": 123,
    "errorRate": 123,
    "byType": [
      {
        "type": "<string>",
        "count": 123,
        "percentage": 123,
        "description": "<string>"
      }
    ],
    "byEndpoint": [
      {}
    ],
    "byStatusCode": [
      {}
    ]
  },
  "rateLimits": {
    "current": {
      "requestsPerMinute": 123,
      "requestsPerHour": 123,
      "requestsPerDay": 123
    },
    "usage": {
      "requestsPerMinute": 123,
      "requestsPerHour": 123,
      "requestsPerDay": 123
    },
    "utilization": {
      "requestsPerMinute": 123,
      "requestsPerHour": 123,
      "requestsPerDay": 123
    }
  },
  "alerts": [
    {
      "type": "<string>",
      "message": "<string>",
      "priority": "<string>",
      "recommendation": "<string>"
    }
  ],
  "pagination": {
    "total": 123,
    "limit": 123,
    "offset": 123,
    "hasMore": true
  },
  "timestamp": "<string>"
}

GET

developer

usage

Get Usage

curl --request GET \
  --url https://api-mainnet.onzks.com/v1/developer/usage \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api-mainnet.onzks.com/v1/developer/usage', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api-mainnet.onzks.com/v1/developer/usage",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api-mainnet.onzks.com/v1/developer/usage"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api-mainnet.onzks.com/v1/developer/usage")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "success": true,
  "usage": {
    "totalRequests": 123,
    "successfulRequests": 123,
    "failedRequests": 123,
    "successRate": 123,
    "averageLatency": 123,
    "peakLatency": 123,
    "requestsPerMinute": 123,
    "requestsPerHour": 123,
    "requestsPerDay": 123,
    "peakRequestsPerMinute": 123,
    "peakRequestsPerHour": 123,
    "dataTransferred": 123,
    "averageDataPerRequest": 123
  },
  "timeSeries": [
    {
      "timestamp": "<string>",
      "requests": 123,
      "successfulRequests": 123,
      "failedRequests": 123,
      "averageLatency": 123,
      "peakLatency": 123,
      "dataTransferred": 123
    }
  ],
  "breakdown": {
    "byEndpoint": [
      {
        "endpoint": "<string>",
        "requests": 123,
        "successRate": 123,
        "averageLatency": 123,
        "dataTransferred": 123
      }
    ],
    "byMethod": [
      {}
    ],
    "byStatusCode": [
      {}
    ],
    "byKey": [
      {}
    ]
  },
  "errors": {
    "totalErrors": 123,
    "errorRate": 123,
    "byType": [
      {
        "type": "<string>",
        "count": 123,
        "percentage": 123,
        "description": "<string>"
      }
    ],
    "byEndpoint": [
      {}
    ],
    "byStatusCode": [
      {}
    ]
  },
  "rateLimits": {
    "current": {
      "requestsPerMinute": 123,
      "requestsPerHour": 123,
      "requestsPerDay": 123
    },
    "usage": {
      "requestsPerMinute": 123,
      "requestsPerHour": 123,
      "requestsPerDay": 123
    },
    "utilization": {
      "requestsPerMinute": 123,
      "requestsPerHour": 123,
      "requestsPerDay": 123
    }
  },
  "alerts": [
    {
      "type": "<string>",
      "message": "<string>",
      "priority": "<string>",
      "recommendation": "<string>"
    }
  ],
  "pagination": {
    "total": 123,
    "limit": 123,
    "offset": 123,
    "hasMore": true
  },
  "timestamp": "<string>"
}

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.

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.

Parameters

string

Specific API key ID to get usage for (optional)

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

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

boolean

Include detailed breakdown by endpoint (default: true)

boolean

Include error statistics (default: true)

boolean

Include latency statistics (default: true)

string

Sort results by field

requests - By request count (default)
errors - By error count
latency - By average latency
timestamp - By timestamp

string

Sort order

desc - Descending (default)
asc - Ascending

number

Number of results to return (default: 100, max: 1000)

number

Number of results to skip for pagination (default: 0)

Response

boolean

Indicates if the request was successful

object

Usage statistics

Show usage properties

number

Total requests in the timeframe

number

Number of successful requests

number

Number of failed requests

number

Success rate percentage (0-100)

number

Average response latency in milliseconds

number

Peak response latency in milliseconds

number

Average requests per minute

number

Average requests per hour

number

Average requests per day

number

Peak requests per minute

number

Peak requests per hour

number

Total data transferred in bytes

number

Average data per request in bytes

array

Time series data points

Show timeSeries properties

string

ISO 8601 timestamp of the data point

number

Number of requests in this period

number

Number of successful requests

number

Number of failed requests

number

Average latency in this period

number

Peak latency in this period

number

Data transferred in this period

object

Breakdown by endpoint

Show breakdown properties

array

Usage by endpoint

Show endpoint properties

string

API endpoint

number

Number of requests

number

Success rate percentage

number

Average latency

number

Data transferred

array

Usage by HTTP method

array

Usage by status code

array

Usage by API key

object

Error statistics

Show errors properties

number

Total number of errors

number

Error rate percentage

array

Errors by type

Show error type properties

string

Error type

number

Number of errors

number

Percentage of total errors

string

Error description

array

Errors by endpoint

array

Errors by status code

object

Rate limit information

Show rateLimits properties

object

Current rate limits

Show current properties

number

Requests per minute limit

number

Requests per hour limit

number

Requests per day limit

object

Current usage against limits

Show usage properties

number

Current requests per minute

number

Current requests per hour

number

Current requests per day

object

Rate limit utilization percentages

Show utilization properties

number

Per-minute utilization percentage

number

Per-hour utilization percentage

number

Per-day utilization percentage

array

Usage alerts and recommendations

Show alert properties

string

Alert type

string

Alert message

string

Alert priority (high, medium, low)

string

Recommended action

object

Pagination information

Show pagination properties

number

Total number of data points

number

Number of data points returned

number

Current offset

boolean

Whether more data is available

string

ISO 8601 timestamp of the response

Examples

curl "https://api.onzks.com/v1/developer/usage" \
  -H "Authorization: Bearer YOUR_API_KEY"

curl "https://api.onzks.com/v1/developer/usage?keyId=key_1234567890abcdef" \
  -H "Authorization: Bearer YOUR_API_KEY"

curl "https://api.onzks.com/v1/developer/usage?timeframe=7d&granularity=day" \
  -H "Authorization: Bearer YOUR_API_KEY"

curl "https://api.onzks.com/v1/developer/usage?includeBreakdown=true&includeErrors=true" \
  -H "Authorization: Bearer YOUR_API_KEY"

curl "https://api.onzks.com/v1/developer/usage?granularity=hour&limit=24" \
  -H "Authorization: Bearer YOUR_API_KEY"

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 });

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)

Response Example

{
  "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:

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:

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:

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:

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:

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:

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:

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:

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

4. Cost Optimization

Optimize costs:

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

List API Keys - View all API keys
Create API Key - Create new API keys
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.

API Documentation

Identity

Scores

Achievements

Trading

Trust Layer

Developer Tools

Overview

Parameters

Response

Examples

Response Example

Use Cases

1. Usage Monitoring Dashboard

2. Performance Optimization

3. Cost Analysis

4. Alert Management

5. Capacity Planning

Best Practices

1. Regular Monitoring

2. Automated Alerts

3. Performance Optimization

4. Cost Optimization

Troubleshooting

”No usage data found”

”Invalid timeframe”

”Invalid granularity”

Rate Limits

​Overview

​Parameters

​Response

​Examples

​Response Example

​Use Cases

​1. Usage Monitoring Dashboard

​2. Performance Optimization

​3. Cost Analysis

​4. Alert Management

​5. Capacity Planning

​Best Practices

​1. Regular Monitoring

​2. Automated Alerts

​3. Performance Optimization

​4. Cost Optimization

​Related Endpoints

​Troubleshooting

​”No usage data found”

​”Invalid timeframe”

​”Invalid granularity”

​Rate Limits

Overview

Parameters

Response

Examples

Response Example

Use Cases

1. Usage Monitoring Dashboard

2. Performance Optimization

3. Cost Analysis

4. Alert Management

5. Capacity Planning

Best Practices

1. Regular Monitoring

2. Automated Alerts

3. Performance Optimization

4. Cost Optimization

Related Endpoints

Troubleshooting

”No usage data found”

”Invalid timeframe”

”Invalid granularity”

Rate Limits