# What Are the Rate Limits for Plugin API Calls?

> Understand OpenAI plugin API rate limits. Learn how third-party services enforce them and how to check remaining requests using HTTP headers and 429 status codes.

- Repository: [OpenAI/plugins](https://github.com/openai/plugins)
- Tags: faq
- Published: 2026-06-14

---

**Rate limits for OpenAI plugin API calls are enforced by the underlying third-party service (such as Zoom, GitHub, or Slack), not by OpenAI itself, and are communicated via standard HTTP headers like `X-RateLimit-Remaining` and HTTP 429 status codes.**

The `openai/plugins` repository exposes REST-style endpoints that inherit the quota models of the external APIs they consume. Each plugin's rate limiting behavior is documented in its respective reference files, requiring developers to implement client-side throttling and retry logic based on the specific constraints of the integrated service.

## How Rate Limiting Works in OpenAI Plugins

OpenAI plugins do not impose a universal rate limit across all integrations. Instead, each plugin respects the **rate-limiting model defined by the third-party service** it communicates with. For example, the Zoom plugin implements limits specific to Zoom's API tiers.

| Plugin | Limit Type | Typical Value | Reporting Mechanism |
|--------|------------|---------------|---------------------|
| **Zoom** | Per-second request quota | Light endpoints: ~10 req/s<br>Heavy endpoints: ~100 req/s (per account) | `X-RateLimit-Remaining` header |
| **Zoom** | Daily request quota | Varies by plan (e.g., 1,000 req/day for free accounts) | `X-RateLimit-Reset` header |
| **Other services**<br>(Google Sheets, GitHub, Slack) | Per-endpoint or per-user limits | Usually a few hundred calls per minute | `X-RateLimit-*` headers or 429 error body |

When you exceed these quotas, the service returns **HTTP 429 Too Many Requests** along with a JSON payload containing a `retry-after` field or similar guidance. Your integration must read these signals and back off accordingly.

## Standard Rate Limit Headers and Response Codes

Every plugin API response includes standard headers that communicate your current quota status:

- **`X-RateLimit-Remaining`**: The number of requests left in the current window
- **`X-RateLimit-Reset`**: Unix timestamp indicating when the quota resets
- **`Retry-After`**: Seconds to wait before retrying (sent with 429 responses)

When `X-RateLimit-Remaining` approaches zero, you should throttle subsequent requests to avoid hitting the hard limit. If you receive a 429 status, you must respect the `Retry-After` value before attempting the call again.

## Implementing Rate Limit Handling

Robust integrations should check headers proactively and implement exponential backoff when receiving 429 errors.

### Node.js Retry Logic with Exponential Backoff

The following pattern handles generic 429 responses by reading the `Retry-After` header and waiting before retrying:

```javascript
async function callPluginApi(url, options = {}) {
  const resp = await fetch(url, options);
  if (resp.status === 429) {
    const retryAfter = resp.headers.get('Retry-After') || 1; // seconds
    console.warn(`Rate limit hit – retrying in ${retryAfter}s`);
    await new Promise(r => setTimeout(r, retryAfter * 1000));
    return callPluginApi(url, options); // retry once
  }
  return resp.json();
}

```

### Python Handling for Zoom API Limits

For Zoom-specific implementations, this helper polls the endpoint and automatically waits when rate limited:

```python
import time, requests

def zoom_get(url, token):
    headers = {"Authorization": f"Bearer {token}"}
    while True:
        r = requests.get(url, headers=headers)
        if r.status_code == 429:
            wait = int(r.headers.get("Retry-After", "1"))
            print(f"Zoom rate limit – waiting {wait}s")
            time.sleep(wait)
            continue
        r.raise_for_status()
        return r.json()

```

### Monitoring Quota Thresholds

To implement proactive throttling, check the remaining quota before making calls:

```javascript
const resp = await fetch(pluginEndpoint);
const remaining = resp.headers.get('X-RateLimit-Remaining');
if (remaining && Number(remaining) < 10) {
  console.log(`Only ${remaining} calls left – consider throttling`);
}

```

## Key Reference Files in the Repository

The `openai/plugins` repository contains detailed documentation for each plugin's rate limiting strategy:

- **[`plugins/zoom/skills/rest-api/references/rate-limits.md`](https://github.com/openai/plugins/blob/main/plugins/zoom/skills/rest-api/references/rate-limits.md)**: Documents Zoom's per-second and daily limits, including header names and account-specific quotas.
- **[`plugins/zoom/skills/rest-api/concepts/rate-limiting-strategy.md`](https://github.com/openai/plugins/blob/main/plugins/zoom/skills/rest-api/concepts/rate-limiting-strategy.md)**: Provides recommended back-off patterns and retry strategies specific to Zoom's API behavior.
- **`plugins/*/skills/**/references/*.md`**: General pattern across all plugins where third-party service limits are documented (e.g., GitHub, Slack, Google Sheets).

These files contain the authoritative limits for each service and should be consulted when building production integrations.

## Summary

- **No universal limits**: OpenAI plugins inherit rate limits from the underlying third-party APIs rather than enforcing platform-wide quotas.
- **Standard headers**: Services communicate limits via `X-RateLimit-Remaining`, `X-RateLimit-Reset`, and `Retry-After` headers.
- **HTTP 429 handling**: Exceeding limits triggers a 429 status code; integrations must implement exponential backoff and respect `Retry-After` values.
- **Service-specific documentation**: Each plugin's reference files (e.g., [`plugins/zoom/skills/rest-api/references/rate-limits.md`](https://github.com/openai/plugins/blob/main/plugins/zoom/skills/rest-api/references/rate-limits.md)) contain the exact limits and handling patterns for that service.

## Frequently Asked Questions

### Does OpenAI impose its own rate limits on plugin API calls?

No. According to the `openai/plugins` source code, the platform itself does not impose a universal rate limit on plugin API calls. Each plugin inherits the rate-limiting model from the third-party service it integrates with, such as Zoom, GitHub, or Slack.

### What HTTP status code indicates a rate limit has been exceeded?

When you exceed the quota defined by the underlying service, the API returns **HTTP 429 Too Many Requests**. This response includes headers like `Retry-After` indicating how many seconds to wait before retrying the request.

### How can I find the specific rate limits for a particular plugin?

Check the plugin's reference documentation within the repository. For example, Zoom's limits are defined in [`plugins/zoom/skills/rest-api/references/rate-limits.md`](https://github.com/openai/plugins/blob/main/plugins/zoom/skills/rest-api/references/rate-limits.md), while general rate-limiting strategies are documented in [`plugins/zoom/skills/rest-api/concepts/rate-limiting-strategy.md`](https://github.com/openai/plugins/blob/main/plugins/zoom/skills/rest-api/concepts/rate-limiting-strategy.md). Each third-party integration follows this file structure pattern.

### Should I implement exponential backoff when handling 429 errors?

Yes. The reference implementations recommend exponential backoff (e.g., 250ms → 500ms → 1s) combined with respect for the `Retry-After` header value. This approach prevents aggressive retry loops that could trigger additional rate limiting or temporary bans from the third-party service.