Rate Limits

Stream applies rate limits to protect both your application and our infrastructure. Rate limits prevent:

• Integration issues or abuse from degrading your app’s performance (excessive API calls trigger client-side events)
• Resource consumption beyond what is provisioned for your plan
• Common integration mistakes, such as opening multiple WebSocket connections per user

Rate limits are applied per API endpoint and platform on a 1-minute window. Different platforms (iOS, Android, Web, Server) have independent counters for each endpoint.

Inspecting Rate Limits

Check your current rate limit quotas and usage in the dashboard or via the API.

// Server-side platform only
const limits = await client.getRateLimits({ serverSide: true });

// All platforms
const limits = await client.getRateLimits();

// Specific platforms
const limits = await client.getRateLimits({ ios: true, android: true });

// Specific endpoints
const limits = await client.getRateLimits({
  endpoints: ["QueryChannels", "SendMessage"],
});

# Server-side platform only
limits = client.get_rate_limits(server_side=True)

# All platforms
limits = client.get_rate_limits()

# Specific platforms
limits = client.get_rate_limits(ios=True, android=True)

# Specific endpoints
limits = client.get_rate_limits(endpoints=["QueryChannels", "SendMessage"])

// Server-side platform only
limits, _ := client.GetRateLimits(ctx, WithServerSide())

// All platforms
limits, _ := client.GetRateLimits(ctx)

// Specific platforms
limits, _ := client.GetRateLimits(ctx, WithIOS(), WithAndroid())

// Specific endpoints
limits, _ := client.GetRateLimits(ctx, WithEndpoints("QueryChannels", "SendMessage"))

// Server-side platform only
var limits = await appClient.GetRateLimitsAsync(new GetRateLimitsOptions().WithServerSide());

// All platforms
var limits = await appClient.GetRateLimitsAsync(new GetRateLimitsOptions());

// Specific platforms
var limits = await appClient.GetRateLimitsAsync(new GetRateLimitsOptions().WithIOS().WithAndroid());

// Specific endpoints
var limits = await appClient.GetRateLimitsAsync(new GetRateLimitsOptions().WithEndpoint("QueryChannels").WithEndpoint("SendMessage"));

# Server-side platform only
limits = client.get_rate_limits(serverSide: true)

# All platforms
limits = client.get_rate_limits()

# Specific platforms
limits = client.get_rate_limits(ios: true, android: true)

# Specific endpoints
limits = client.get_rate_limits(endpoints: ['QueryChannels', 'SendMessage'])

// Server-side platform only
$limits = $client->getRateLimits(true);

// All platforms
$limits = $client->getRateLimits();

// Specific platforms
$limits = $client->getRateLimits(false, true, true);

// Specific endpoints
$limits = $client->getRateLimits(false, false, false, array("QueryChannels", "SendMessage"));

// Server-side platform only
var limits = App.getRateLimits().serverSide(true).request();

// All platforms
var limits = App.getRateLimits().request();

// Specific platforms
var limits = App.getRateLimits().ios(true).android(true).request();

// Specific endpoints
var limits = App.getRateLimits().endpoint("QueryChannels").endpoint("SendMessage").request();

The response includes the 1-minute limit, remaining quota, and window reset timestamp.

Rate Limit Headers

All API responses include rate limit information in headers.

Types of Rate Limits

User Rate Limits

Each user is limited to 60 requests per minute per endpoint and platform. This prevents a single user from consuming your entire application quota. Your server is not subject to user rate limits.

App Rate Limits

App rate limits apply per endpoint and platform combination. Stream supports four platforms:

Rate limits are not shared across platforms. If a server-side script hits a rate limit, your mobile and web applications are unaffected.

App rate limits are enforced both per minute and per second. The per-second limit equals the per-minute limit divided by 30 to allow for bursts.

When a rate limit is exceeded, all calls from the same app, platform, and endpoint return HTTP status 429.

Handling Rate Limit Errors

When you receive a 429 status code, implement exponential back-off retry logic. Use the X-RateLimit-Reset header to determine when to retry.

Avoiding Rate Limits

1. Add delays to scripts - The most common cause of rate limits. Add timeouts between successive API calls in batch scripts or cronjobs.

2. Use batch endpoints - Instead of 100 individual calls, use batch endpoints to update multiple users in one request.

3. Check client-side rendering logic - Infinite pagination bugs or other client-side issues can trigger excessive API calls.

4. Avoid redundant queries - Channel creation is an upsert operation. Do not call QueryChannels to check if a channel exists before creating it. See Query Channels.

5. Use one WebSocket per user - Multiple WebSocket connections per user cause performance issues, billing problems, and unexpected behavior. See Initialization & Users.

6. Follow livestream best practices - High-volume messaging scenarios require additional optimization. See Livestream Best Practices.

Requesting Higher Limits

• Standard plans - Stream may increase limits after reviewing your integration to confirm optimal usage of default limits.
• Enterprise plans - Stream reviews your architecture and sets appropriate limits for your production application.

Rate Limits by Endpoint

Default rate limits for self-serve plans (per minute, per platform).