With the ever-increasing proliferation of the Internet of Things (IoT), leveraging REST APIs for managing and retrieving critical data is now a key task for developers. One such API is the IoT Accelerator REST API, accessible at https://iot-api.aeris.com. Like many modern APIs, it employs rate limiting to ensure fair usage and maintain optimal performance. This guide explains how rate limiting works in our API, how to read and monitor usage headers, strategies to avoid exceeding limits, and how to handle errors if they occur.
Related best practice: See our Best Practices for Using the JWT Authentication Token to learn how to reuse authentication tokens efficiently and avoid unnecessary API calls that may contribute to rate limit usage.
How Rate Limiting Works in the IoT Accelerator REST API
Rate limiting controls the number of requests that can be made in a specific time window. The IoT Accelerator REST API uses both per-second and per-minute limits. When a client exceeds these thresholds, the server returns a 429 Too Many Requests status code, and additional requests may be blocked until the limit window resets.
Rate Limit Headers
Every response from the API includes headers to let you check your current usage against your limits.
| Header | Description |
|---|---|
X-RateLimit-Limit-Second |
Maximum requests allowed in a single second. |
X-RateLimit-Limit-Minute |
Maximum requests allowed in a single minute. |
X-RateLimit-Remaining-Second |
Requests remaining in the current second window. |
X-RateLimit-Remaining-Minute |
Requests remaining in the current minute window. |
Monitoring & Reading Rate Limit Headers
Before implementing rate limit handling, understand how to read these headers inside your application. Here’s a quick Python example:
def fetch_data(endpoint):
url = f"{BASE_URL}/{endpoint}"
headers = {'Authorization': f"Bearer {API_KEY}"}
response = requests.get(url, headers=headers)
print(
f"Limit/sec: {response.headers.get('X-RateLimit-Limit-Second')}, "
f"Remaining/sec: {response.headers.get('X-RateLimit-Remaining-Second')}, "
f"Limit/min: {response.headers.get('X-RateLimit-Limit-Minute')}, "
f"Remaining/min: {response.headers.get('X-RateLimit-Remaining-Minute')}"
)
return response.json()Strategies to Avoid Exceeding Rate Limits
- Throttle Requests: Pace your requests so they never exceed per-second or per-minute limits.
- Batch Processing: Combine multiple actions into a single request when possible.
- Cache Responses: Reuse previously retrieved data to avoid unnecessary calls.
- Monitor Usage: Continuously check headers to dynamically adjust request rates.
- Exponential Backoff: When hitting limits, retry after progressively longer delays.
Implementing Request Throttling
Below are examples for Python and JavaScript showing how to throttle based on the per-second and per-minute headers.
Python Example
import time
import requests
BASE_URL = 'https://iot-api.aeris.com'
API_KEY = 'your_api_key'
def fetch_data(endpoint):
url = f"{BASE_URL}/{endpoint}"
headers = {'Authorization': f"Bearer {API_KEY}"}
response = requests.get(url, headers=headers)
limit_second = int(response.headers.get('X-RateLimit-Limit-Second', 1))
limit_minute = int(response.headers.get('X-RateLimit-Limit-Minute', 1))
remaining_second = int(response.headers.get('X-RateLimit-Remaining-Second', limit_second))
remaining_minute = int(response.headers.get('X-RateLimit-Remaining-Minute', limit_minute))
print(f"Limit/sec: {limit_second}, Remaining/sec: {remaining_second}, "
f"Limit/min: {limit_minute}, Remaining/min: {remaining_minute}")
return response.json(), remaining_second, remaining_minute
def main():
endpoints = ['/devices', '/data']
for endpoint in endpoints:
data, rem_sec, rem_min = fetch_data(endpoint)
print(data)
if rem_sec <= elif="elif" rem_min="rem_min"><= if="if" __name__="=" __main__="__main__">JavaScript Example
const axios = require('axios');
const BASE_URL = 'https://iot-api.aeris.com';
const API_KEY = 'your_api_key';
const MAX_RETRIES = 5;
async function fetchData(endpoint, retries = 0) {
const url = `${BASE_URL}${endpoint}`;
const headers = { 'Authorization': `Bearer ${API_KEY}` };
try {
const response = await axios.get(url, { headers });
const limitSec = parseInt(response.headers['x-ratelimit-limit-second'] || '0', 10);
const limitMin = parseInt(response.headers['x-ratelimit-limit-minute'] || '0', 10);
const remSec = parseInt(response.headers['x-ratelimit-remaining-second'] || '0', 10);
const remMin = parseInt(response.headers['x-ratelimit-remaining-minute'] || '0', 10);
console.log(`Limit/sec: ${limitSec}, Remaining/sec: ${remSec}, Limit/min: ${limitMin}, Remaining/min: ${remMin}`);
console.log(response.data);
} catch (error) {
if (error.response && error.response.status === 429 && retries fetchData(endpoint, retries + 1), retryAfter * 1000);
} else {
console.error('Request failed:', error);
}
}
}
fetchData('/devices');Handling Rate Limit Errors
Even with throttling, you may occasionally reach the limit. When a 429 Too Many Requests response is returned, your application should handle it gracefully and retry after a delay.
JavaScript Error Handling Example
async function fetchData(endpoint) {
const url = `${BASE_URL}${endpoint}`;
const headers = { 'Authorization': `Bearer ${API_KEY}` };
try {
const response = await axios.get(url, { headers });
console.log(response.data);
} catch (error) {
if (error.response && error.response.status === 429) {
console.log('Rate limit exceeded. Retrying after a short delay...');
setTimeout(() = fetchData(endpoint), 1000);
} else {
console.error('Request failed:', error);
}
}
}Conclusion
To maintain smooth operation and avoid outages, always:
- Monitor your per-second and per-minute limits using the provided headers
- Throttle requests to stay under the limit
- Cache and batch to reduce API calls
- Handle 429 errors gracefully
Combining these strategies with optimal JWT token usage (see our guide here) will give you the best chance of staying within limits while maintaining high performance.
0 Comments