# Rate Limits
Source: https://docs.tensormachine.ai/rate-limits

## Limits by plan

| Plan | Requests/min | Tokens/month | Concurrent requests |
|------|-------------|-------------|---------------------|
| Free | 10 | 100K | 2 |
| Developer | 60 | 5M | 10 |
| Pro | 300 | 50M | 50 |
| Enterprise | Custom | Custom | Custom |

Limits apply per API key. Creating multiple keys does not increase per-account limits.

## Rate limit headers

Every response includes headers showing your current usage:

```
X-RateLimit-Limit-Requests: 60
X-RateLimit-Remaining-Requests: 43
X-RateLimit-Limit-Tokens: 5000000
X-RateLimit-Remaining-Tokens: 4821309
X-RateLimit-Reset-Requests: 2026-06-24T10:30:00Z
```

## Handling 429 responses

When you exceed a limit, the API returns `429 Too Many Requests` with a `Retry-After` header:

```json
{
  "error": {
    "message": "Rate limit exceeded. Please retry after 12 seconds.",
    "type": "rate_limit_error",
    "code": "rate_limit_exceeded"
  }
}
```

### Python — exponential backoff

```python
import time
import random
from openai import OpenAI, RateLimitError

client = OpenAI(api_key="tx_live_...", base_url="https://edge.tensormachine.ai/v1")

def call_with_retry(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="z-ai/glm-5.2",
                messages=messages,
            )
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            wait = (2 ** attempt) + random.random()
            time.sleep(wait)
```

### Node.js — exponential backoff

```typescript
import OpenAI from 'openai';

const client = new OpenAI({ apiKey: process.env.TENSORMACHINE_API_KEY, baseURL: 'https://edge.tensormachine.ai/v1' });

async function callWithRetry(messages: OpenAI.ChatCompletionMessageParam[], retries = 5) {
  for (let i = 0; i < retries; i++) {
    try {
      return await client.chat.completions.create({ model: 'z-ai/glm-5.2', messages });
    } catch (e: unknown) {
      if (e instanceof OpenAI.RateLimitError && i < retries - 1) {
        await new Promise(r => setTimeout(r, Math.pow(2, i) * 1000));
        continue;
      }
      throw e;
    }
  }
}
```

## Best practices

- **Batch small requests** — if you process many short texts, combine them into a single prompt when possible
- **Use streaming** — streaming responses begin faster and reduce perceived latency
- **Cache deterministic outputs** — for identical prompts with `temperature: 0`, cache the response
- **Monitor usage in the dashboard** — real-time token consumption per key

## Increasing limits

To increase your rate limits, upgrade your plan at [tensormachine.ai/pricing](/pricing) or contact enterprise@tensormachine.ai for custom quotas.