# API rate limits

> How many REST API requests your plan allows per minute and per day, the headers that show what is left, and what to do when you get a 429.

Source: https://tadabase.com/docs/developers/rate-limiting  
Status: Verified Nov 17, 2026. Checked against the current product

Every REST API request counts toward two limits: requests per minute and requests per day. Your plan sets both numbers. This page explains how the limits are counted, how to see what you have left, and how to keep an integration under them.

## How the limits work

The numbers depend on your plan. Compare them on the [pricing page](https://tadabase.com/pricing): look for **API rate limit** under **API & integrations**. The same table shows whether a plan includes **REST API access** at all.

- **The limits belong to the account that owns the app.** Every app you own and every API key in them share the same per-minute and per-day count. A busy integration on one app can use up the limit for your other apps.
- **One key cannot use the whole limit when you have several.** If your account has more than one active API key, each key can use at most half of the per-minute and per-day limit. This stops one integration that retries in a loop from blocking all the others. With a single active key, that key can use the whole limit.
- **Each window starts with its first request.** The per-minute count resets 60 seconds after the first request in the window. The per-day count resets 24 hours after the first request in its window, not at midnight.
- **Every request counts,** including calls to the status endpoint below and requests that end in an error.

## Read what you have left from the response headers

Each response to a request with valid credentials carries these headers. Read them to slow down before you reach the limit instead of after.

| Header | What it tells you |
| --- | --- |
| `X-RateLimit-Limit` | Requests allowed per minute. |
| `X-RateLimit-Remaining` | Requests left in the current minute. |
| `X-Retry-After` | Seconds until the per-minute count resets. |
| `X-RateLimit-Reset` | When the per-minute count resets, as a Unix timestamp. |
| `X-RateLimit-Daily-Limit` | Requests allowed per day. |
| `X-RateLimit-Daily-Remaining` | Requests left in the current day window. |
| `X-Daily-Retry-After` | Seconds until the per-day count resets. |
| `X-Daily-RateLimit-Reset` | When the per-day count resets, as a Unix timestamp. |

A request refused because its credentials are missing or wrong does not carry these headers.

## Check your limits and key permissions

Call the status endpoint with your usual three headers to see your limits, what is left, and what the API key is allowed to do. The call itself counts as one request.

```bash
curl https://api.tadabase.io/api/v1/status \
  -H 'X-Tadabase-App-id: YOUR_APP_ID' \
  -H 'X-Tadabase-App-Key: YOUR_API_KEY' \
  -H 'X-Tadabase-App-Secret: YOUR_API_SECRET'
```

The response looks like this (the `permissions` object is shortened here):

```json
{
  "current_code": 200,
  "api_key": {
    "id": "4yQk924rgP",
    "status": "Active",
    "created_at": "2026-01-15 10:30:00"
  },
  "permissions": {
    "read": true,
    "create": true,
    "update": true,
    "delete": false,
    "logs": true
  },
  "per_minute_limit": {
    "allowed": 60,
    "remaining": 59,
    "resets_in_seconds": 60,
    "reset_timestamp": 1795000000
  },
  "per_day_limit": {
    "allowed": 10000,
    "remaining": 9850,
    "resets_in_seconds": 72511,
    "reset_timestamp": 1795072000
  }
}
```

| Field | Meaning |
| --- | --- |
| `api_key` | The key's ID, its status (`Active` or `Inactive`) and when it was created. |
| `permissions` | `true` or `false` for each permission switch on the key, such as `read` (**Allow Reads**), `create` and `update` (**Allow Updates**), `delete` (**Allow Delete**), `tasks`, `workflows`, `pages`, `imports`, `exports`, `logs`, `pdf_forms`, `pdf_pages`, `webhooks`, `backups`, `formulas` and `layouts`. |
| `per_minute_limit`, `per_day_limit` | The same numbers as the headers above: `allowed`, `remaining`, `resets_in_seconds` and `reset_timestamp`. |

The numbers in the example are made up. Your own come from your plan.

To see how many requests each key made per day, open **Settings** > **API Keys** and click **View Daily Usages**. See [See every API request in the logs](https://tadabase.com/docs/developers/api-request-logs).

## When you go over the limit

A request over the per-minute limit gets HTTP status `429` and this body:

```json
{
  "type": "error",
  "msg": "There has been too many attempts in the last minute. Please try again soon. "
}
```

Over the per-day limit, the message is `There has been too many attempts in the last 24 hours.` Nothing in the request was carried out. Wait for the window to reset (`X-Retry-After` or `X-Daily-Retry-After`) and send it again.

A different `429` message, `Too many failed requests. Please check your API credentials and try again later.`, means many requests from your IP address had missing or wrong credentials. It is not your plan limit: fix the credentials, then wait a few minutes. See [Fix common API errors](https://tadabase.com/docs/developers/error-handling).

## Retry after a 429

Wait the number of seconds in `X-Retry-After` before trying again, and stop retrying when the daily count is used up. For example, in JavaScript:

```javascript
async function callTadabase(url, options, attempt = 0) {
  const res = await fetch(url, options);
  if (res.status !== 429 || attempt >= 5) return res;

  // Out of requests for the day: retrying now will not help.
  if (res.headers.get('X-RateLimit-Daily-Remaining') === '0') return res;

  // Wait until the minute resets (or back off 1, 2, 4... seconds).
  const wait = Number(res.headers.get('X-Retry-After')) || 2 ** attempt;
  await new Promise((resolve) => setTimeout(resolve, wait * 1000));
  return callTadabase(url, options, attempt + 1);
}
```

> **Do not retry at once:** Retrying a refused request straight away counts as another request and keeps you over the limit. Always wait first.

## Use fewer requests

- **Ask for more records per page.** A records request returns at most 100 records per page; set `limit=100` and page through with `page` instead of asking for small pages. See [Sorting and pagination](https://tadabase.com/docs/developers/sorting-and-pagination).
- **Ask only for the fields you need** with `fields`, a comma-separated list of field slugs such as `fields=field_33,field_34`. Responses are smaller and faster.
- **Update many records in one call** with the batch update endpoint instead of one request per record. See [Batch operations](https://tadabase.com/docs/developers/batch-operations).
- **Cache what rarely changes,** such as the list of tables (`GET /api/v1/data-tables`), fields and roles, instead of reading them before every call.
- **Spread scheduled jobs out.** If a job runs every hour, pace its requests across the minute rather than sending them all at once.
- **Speed up bulk writes.** When you save many records, add the header `X-Tadabase-Queue-Equation: 1` to each save. Equations for the record then run in the background, so each request returns sooner.
- **Find the busy key.** **View Daily Usages** on **Settings** > **API Keys** shows requests per day for each key, so you can see which integration uses the most.

If your integrations still need more requests, compare the **API rate limit** of each plan on the [pricing page](https://tadabase.com/pricing).
