Reference

Rate Limits & Quotas

Understand AlterLab's rate limits, concurrency caps, and payload restrictions to optimize your integration.

Rate Limits

Rate limits are applied per API key and scale with your account balance:

Tier	Balance	Requests/Minute
Free	$0 - $5	30
Basic	$5 - $50	60
Growth	$50 - $200	100
Scale	$200 - $500	300
High Volume	$500+	500
Enterprise	Custom	up to 10,000

Soft Limits

These are soft limits. Brief bursts above the limit are allowed, but sustained overages will result in 429 errors.

Enterprise Access

Enterprise tier (10,000 RPM / 500 concurrent) is granted by request — it is not unlocked by balance alone. Email [email protected] with your use case and expected request volume to get the is_enterprise flag enabled on your account.

POST Rate Limits

Write requests (POST, PUT, PATCH, DELETE) consume rate limit tokens at 2× the rate of GET requests. A POST request counts as 2 tokens against your per-minute bucket, while a GET request counts as 1 token.

This means the effective POST throughput for each tier is:

Tier	GET Limit (RPM)	Effective POST Limit (RPM)
Free	30	15
Basic	60	30
Growth	100	50
Scale	300	150
High Volume	500	250

Mixed Request Workloads

If you mix GET and POST requests, each POST consumes 2 tokens and each GET consumes 1 token from the same per-minute bucket. Plan accordingly when designing high-throughput pipelines.

Auth Rate Limits

Authentication and account management endpoints are protected by stricter per-IP limits to prevent abuse, independent of your API key tier:

Endpoint	Limit	Window
`POST /auth/register`	3 requests	1 hour
`POST /auth/login`	5 requests	15 minutes
`POST /auth/forgot-password`	3 requests	1 hour
`POST /billing/checkout`	5 requests	1 minute
`POST /scrape/demo`	10 requests	1 hour

Per-IP Enforcement

Auth rate limits are enforced per source IP address, not per API key. Exceeding these limits returns a 429 with a Retry-After header indicating when the window resets.

Concurrency Limits

Maximum number of requests that can be processed simultaneously. Add funds to instantly unlock higher limits:

Account Balance	Tier	Concurrent Requests	Requests/Minute
$0 - $5	Free	3	30
$5 - $50	Basic	10	60
$50 - $200	Growth	15	100
$200 - $500	Scale	25	300
$500+	High Volume	50	500
Enterprise	Enterprise	up to 500	up to 10,000

Instant Upgrades

Tier upgrades are instant. Add funds to your account and immediately get higher concurrency limits—no waiting period.

Payload Limits

Limit Type	Value	Notes
Request Body Size	1 MB	Maximum size of JSON request
Response Size	50 MB	Maximum scraped content size
URL Length	8,192 chars	Maximum URL length
Headers Size	32 KB	Total custom headers size
Extraction Schema	64 KB	Maximum JSON schema size
Extraction Prompt	4,000 chars	Maximum prompt length

Timeout Limits

Operation	Default	Maximum
Sync Request	90 seconds	300 seconds
Sync Polling (internal)	60 seconds	120 seconds
Async Job	300 seconds	600 seconds
Wait for Selector	30 seconds	60 seconds
PDF/OCR Processing	120 seconds	300 seconds

Long-Running Jobs

For operations that may exceed 60 seconds, use sync: false to get a job ID and poll for results.

Batch Limits

Limit	Value
URLs per batch request	1,000
Concurrent batches	5
Batch result retention	24 hours

Rate Limit Headers

Every response includes headers to help you track your rate limit status:

Response Headers

Bash

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 45
X-RateLimit-Reset: 1704067200
X-Concurrency-Limit: 5
X-Concurrency-Current: 2
Retry-After: 30  # Only on 429 responses

X-RateLimit-LimitMaximum requests per minute

X-RateLimit-RemainingRequests remaining in current window

X-RateLimit-ResetUnix timestamp when limit resets

Retry-AfterSeconds to wait before retrying (429 only)

Handling Rate Limits

1. Check Headers

Monitor X-RateLimit-Remaining and slow down before hitting the limit.

2. Implement Exponential Backoff

On 429 errors, wait and retry with increasing delays: 1s, 2s, 4s, 8s...

Python

import time

def scrape_with_retry(url, max_retries=5):
    for attempt in range(max_retries):
        response = requests.post(...)
        if response.status_code == 429:
            wait = 2 ** attempt  # Exponential backoff
            time.sleep(wait)
            continue
        return response
    raise Exception("Max retries exceeded")

3. Use Batching

Batch requests are processed more efficiently and don't count against per-minute limits the same way.

4. Queue Requests

Use a job queue (Redis, RabbitMQ) to throttle requests and handle retries gracefully.

Increasing Limits

Add Funds

Your limits automatically increase as your account balance grows. See the tier tables above.

Enterprise Plans

For custom limits, dedicated infrastructure, or SLA guarantees, contact our sales team.

Need Higher Limits?

Email [email protected] with your use case and we'll work with you on custom limits.

Pricing Error Codes

Last updated: March 2026