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.
- Verified Nov 17, 2026
- Classic builder
- Available on: Business Starter, Business Growth, Business Pro, Business Elite
On this page
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: 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.
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):
{
"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.
When you go over the limit #
A request over the per-minute limit gets HTTP status 429 and this body:
{
"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.
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:
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);
} Use fewer requests #
- Ask for more records per page. A records request returns at most 100 records per page; set
limit=100and page through withpageinstead of asking for small pages. See Sorting and pagination. - Ask only for the fields you need with
fields, a comma-separated list of field slugs such asfields=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.
- 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: 1to 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.
Was this page helpful?
Something wrong or missing on this page? Tell us.