Usage Stats EndpointΒΆ

The /v1/usage endpoint provides detailed statistics about your API usage, including request counts, quota consumption, and rate limit information.


EndpointΒΆ

GET /v1/usage

Request ParametersΒΆ

Parameter Type Required Description
start_date string No Start date for usage stats (ISO 8601 format)
end_date string No End date for usage stats (ISO 8601 format)
granularity string No Data granularity: hour, day, week, month (default: day)

AuthenticationΒΆ

Authentication is handled via the X-API-Key header:

X-API-Key: your-api-key-here

Example RequestsΒΆ

Current Month Usage:

curl -X GET "https://api.reputeapi.com/v1/usage" \
  -H "X-API-Key: your-api-key"

Date Range Usage:

curl -X GET "https://api.reputeapi.com/v1/usage?start_date=2025-01-01&end_date=2025-01-31&granularity=day" \
  -H "X-API-Key: your-api-key"

Python:

import requests
from datetime import datetime, timedelta

url = "https://api.reputeapi.com/v1/usage"
headers = {"X-API-Key": "your-api-key"}

# Get last 7 days of usage
end_date = datetime.now()
start_date = end_date - timedelta(days=7)

params = {
    "start_date": start_date.isoformat(),
    "end_date": end_date.isoformat(),
    "granularity": "day"
}

response = requests.get(url, headers=headers, params=params)
usage = response.json()

print(f"Total requests: {usage['summary']['total_requests']}")
print(f"Quota remaining: {usage['quota']['remaining']}")

JavaScript:

const response = await fetch(
  'https://api.reputeapi.com/v1/usage',
  {
    headers: {
      'X-API-Key': 'your-api-key'
    }
  }
);

const usage = await response.json();

console.log(`Total requests: ${usage.summary.total_requests}`);
console.log(`Quota remaining: ${usage.quota.remaining}`);


Response FormatΒΆ

Success Response (200 OK)ΒΆ

{
  "account": {
    "api_key_id": "key_abc123",
    "tier": "premium",
    "created_at": "2025-01-01T00:00:00Z"
  },
  "period": {
    "start_date": "2025-01-01T00:00:00Z",
    "end_date": "2025-01-31T23:59:59Z",
    "granularity": "day"
  },
  "quota": {
    "monthly_limit": 50000,
    "used": 12345,
    "remaining": 37655,
    "reset_date": "2025-02-01T00:00:00Z",
    "percentage_used": 24.69
  },
  "rate_limits": {
    "requests_per_minute": 120,
    "current_minute_usage": 5,
    "next_reset": "2025-01-20T15:31:00Z"
  },
  "summary": {
    "total_requests": 12345,
    "successful_requests": 12100,
    "failed_requests": 245,
    "success_rate": 98.02,
    "endpoints": {
      "/api/v1/check": 8000,
      "/api/v1/score": 3000,
      "/api/v1/recommendations": 1000,
      "/v1/validate": 300,
      "/v1/usage": 45
    },
    "average_response_time_ms": 245,
    "total_domains_validated": 12000
  },
  "daily_breakdown": [
    {
      "date": "2025-01-01",
      "requests": 450,
      "successful": 442,
      "failed": 8,
      "unique_domains": 380,
      "average_response_time_ms": 230
    },
    {
      "date": "2025-01-02",
      "requests": 520,
      "successful": 512,
      "failed": 8,
      "unique_domains": 445,
      "average_response_time_ms": 250
    }
    // ... more daily entries
  ],
  "errors": {
    "by_code": {
      "DNS_RESOLUTION_FAILED": 120,
      "INVALID_DOMAIN": 45,
      "TIMEOUT": 80
    },
    "total": 245
  },
  "top_domains": [
    {
      "domain": "example.com",
      "request_count": 50,
      "last_checked": "2025-01-20T15:30:00Z"
    },
    {
      "domain": "another-example.com",
      "request_count": 42,
      "last_checked": "2025-01-20T14:15:00Z"
    }
    // ... up to 10 top domains
  ]
}

Field DescriptionsΒΆ

Account InformationΒΆ

Field Type Description
account.api_key_id string Identifier for your API key
account.tier string Your subscription tier: free, basic, or premium
account.created_at string ISO 8601 timestamp of account creation

Quota InformationΒΆ

Field Type Description
quota.monthly_limit integer Total requests allowed per month
quota.used integer Requests used in current period
quota.remaining integer Requests remaining in current period
quota.reset_date string When the quota resets
quota.percentage_used number Percentage of quota consumed

Rate LimitsΒΆ

Field Type Description
rate_limits.requests_per_minute integer Max requests per minute for your tier
rate_limits.current_minute_usage integer Requests made in current minute
rate_limits.next_reset string When the current minute window resets

Summary StatisticsΒΆ

Field Type Description
summary.total_requests integer Total API calls in the period
summary.successful_requests integer Number of successful API calls
summary.failed_requests integer Number of failed API calls
summary.success_rate number Percentage of successful requests
summary.endpoints object Request count breakdown by endpoint
summary.average_response_time_ms number Average API response time
summary.total_domains_validated integer Unique domains validated

Granularity OptionsΒΆ

HourΒΆ

curl "https://api.reputeapi.com/v1/usage?granularity=hour" \
  -H "X-API-Key: your-api-key"

Returns hourly breakdown for the last 24 hours.

Day (Default)ΒΆ

curl "https://api.reputeapi.com/v1/usage?granularity=day" \
  -H "X-API-Key: your-api-key"

Returns daily breakdown for the current month.

WeekΒΆ

curl "https://api.reputeapi.com/v1/usage?granularity=week" \
  -H "X-API-Key: your-api-key"

Returns weekly breakdown for the last 12 weeks.

MonthΒΆ

curl "https://api.reputeapi.com/v1/usage?granularity=month" \
  -H "X-API-Key: your-api-key"

Returns monthly breakdown for the last 12 months.


Error ResponsesΒΆ

401 UnauthorizedΒΆ

Invalid or missing API key:

{
  "error": "Unauthorized",
  "message": "Invalid API key",
  "status": 401
}

400 Bad RequestΒΆ

Invalid date format or parameters:

{
  "error": "Bad Request",
  "message": "Invalid date format. Use ISO 8601 format (YYYY-MM-DD)",
  "status": 400
}

Usage Monitoring DashboardΒΆ

CLI Tool ExampleΒΆ

Create a simple CLI tool to monitor usage:

#!/usr/bin/env python3
import requests
import sys

def check_usage(api_key):
    url = "https://api.reputeapi.com/v1/usage"
    headers = {"X-API-Key": api_key}

    response = requests.get(url, headers=headers)
    usage = response.json()

    quota = usage["quota"]
    rate = usage["rate_limits"]

    print(f"\nπŸ“Š API Usage Report")
    print(f"{'='*50}")
    print(f"Tier: {usage['account']['tier'].upper()}")
    print(f"\nMonthly Quota:")
    print(f"  Used:      {quota['used']:,} / {quota['monthly_limit']:,}")
    print(f"  Remaining: {quota['remaining']:,}")
    print(f"  Progress:  {quota['percentage_used']:.1f}%")
    print(f"  Resets:    {quota['reset_date'][:10]}")
    print(f"\nRate Limits:")
    print(f"  Limit:     {rate['requests_per_minute']}/minute")
    print(f"  Current:   {rate['current_minute_usage']}/minute")
    print(f"\nSuccess Rate: {usage['summary']['success_rate']:.2f}%")
    print(f"Avg Response: {usage['summary']['average_response_time_ms']}ms")

    # Warning if quota is running low
    if quota['percentage_used'] > 80:
        print(f"\n⚠️  WARNING: You've used {quota['percentage_used']:.1f}% of your quota!")

    print(f"{'='*50}\n")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python check_usage.py <api-key>")
        sys.exit(1)

    check_usage(sys.argv[1])

Monitoring ScriptΒΆ

Set up automated monitoring with alerts:

import requests
import smtplib
from datetime import datetime

def monitor_usage(api_key, alert_threshold=80):
    """Monitor API usage and send alert if threshold exceeded"""
    url = "https://api.reputeapi.com/v1/usage"
    headers = {"X-API-Key": api_key}

    response = requests.get(url, headers=headers)
    usage = response.json()

    percentage_used = usage["quota"]["percentage_used"]

    if percentage_used > alert_threshold:
        send_alert(
            f"API Quota Alert: {percentage_used:.1f}% used",
            usage
        )
        return True

    return False

def send_alert(subject, usage_data):
    """Send email alert about quota usage"""
    # Implementation depends on your email setup
    pass

Best PracticesΒΆ

1. Regular MonitoringΒΆ

Check your usage regularly to avoid hitting limits:

# Check usage every hour
import schedule
import time

def job():
    usage = get_usage()
    if usage["quota"]["percentage_used"] > 75:
        send_notification("API quota running low")

schedule.every().hour.do(job)

while True:
    schedule.run_pending()
    time.sleep(60)

2. Implement Quota-Aware LogicΒΆ

Adjust your application behavior based on remaining quota:

def should_validate_domain(domain):
    usage = get_usage()
    remaining = usage["quota"]["remaining"]

    if remaining < 100:
        # Switch to cached results only
        return False

    if remaining < 1000:
        # Reduce validation frequency
        return should_validate_less_frequently(domain)

    return True

Store historical usage data to identify patterns:

import sqlite3
from datetime import datetime

def log_usage():
    usage = get_usage()

    conn = sqlite3.connect('usage_history.db')
    cursor = conn.cursor()

    cursor.execute('''
        INSERT INTO usage_logs (timestamp, requests_used, quota_remaining)
        VALUES (?, ?, ?)
    ''', (
        datetime.now().isoformat(),
        usage["quota"]["used"],
        usage["quota"]["remaining"]
    ))

    conn.commit()
    conn.close()

Rate LimitingΒΆ

The /v1/usage endpoint has more generous rate limits:

  • All tiers: 30 requests per minute

This allows frequent monitoring without consuming your main API quota.

Usage Endpoint Does Not Count Against Quota

Calls to the /v1/usage endpoint do not count towards your monthly request quota. Monitor as frequently as needed!


See AlsoΒΆ