What Are the Rate Limits for Plugin API Calls?

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/sHeavy 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(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:

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:

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:

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: 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: 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) 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, while general rate-limiting strategies are documented in 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}