Rate Limits

Automation Runs

An automation run is a single action when an automation is triggered. If an automation fires 5 actions, it'll count as 5 automation runs.

Examples

No-code Automation and Integration:

• When a new record is created, send a Slack message. (1 automation run)
• When a record is updated to the status "Done" in table A, send an e-mail and create a new record in table B. (2 automation runs).

Low-code Automation and Integration:

• Whenever a trigger or function is activated, this will count as an automation run regardless of whether code is present or not (1 automation run). Afterwards, every time a Jestor native method is invoked (regardless of language), it will count as an additional automation run. So the number of automation runs for low-code is:

Automation runs = 1 + n

With n being the number of times a native method is invoked.

In the example below:

result = jestor.table('client_table').get()

for record in result:
    jestor.table('opportunities').insert({"name":record["name"]})

If I have 5 clients, the get() method will return 5 records, and the "for" iteration will invoke jestor.insert 5 times.

For the number of times the native methods are invoked, we have:

• 1 jestor.get() = 1 automation runs
• 5 jestor.insert() = 5 automation runs

n = 1 + 5 = 6

As such, the total number of automation runs will be:

Automation runs = 1+ 6 = 7

Zapier Automation and Integration

• Zapier actions or triggers will count as 1 automation run. So if you have a zap that is defined as:

When a record is created in Jestor -> Update a record in Jestor

This will count as 2 automation runs.

Free No-Code Automations

• Some no-code native automations are free of charge. They will not be considered on your runs-per-month rate limit, but they could have a maximum limit. When not specified a limit, they will be caped at 5.000 runs/month for each automation.
• Free automations will be tagged as "Free" with a green label.

Webhooks

• There are two types of webhooks inside Jestor: Object and Function webhooks. Function webhooks are webhooks that, when activated, run a low-code function. As such, they follow low-code rules: whenever a function webhook is activated, it counts as 1 automation run regardless of whether it has a proper function or not. Afterwards, every time a Jestor native method is invoked (regardless of language), it will count as an additional automation run.

For a more in-depth example, see Low-code Automation and Integration above.

Combining no-code and low-code automations

• It is possible to combine no-code automations with low-code functions. That is: calling upon a low-code function in the middle of your no-code automation. In this scenario, no-code actions will count as 1 automation run each, and the low-code function will follow low-code rules.

For example, if you have an automation sequence that is something like:

• When a new record is created, send a Slack message, then run a low-code function.

You have:

• When a new record is created (1 automation run).
• Send a Slack message (1 automation run).
• Run a low-code function (1 + n automation runs).

So if the low-code function ends up accumulating 8 automation runs, you'll have a total of 10 automation runs every time this sequence is activated.

📘

Automation Runs Limits

It's counted on a per-month basis, non-cumulative.

Every plan has its own rate limit. You can check it out here.

Are Add-on packages available? Yes.

There are some things to keep in mind when dealing with automations:

🚧

Warnings

1. An automation sequence may activate other automation sequences. For example, if you set up an automation that updates a record, then set up an automation that runs when a record is automated, the second sequence will be activated whenever the first one runs. This may create a large, limit-consuming tree of automations, and may even fall in infinite looping (see Infinite loop and circular recursion below).

2. As the mere act of running automations use processing power, automations will count towards your limit even if they fail, regardless of whether they fail because of logical errors, instabilities, or even if they are blocked for recursion or timeout rules.

Automation Chains

Depending on how you set your triggers and actions, automation sequences may set off other automation sequences, and run in parallel across multiple levels. For example, if you have these two automation sequences:

• When a new record is created in Sales, create a record in Agreements.
• When a new record is created in Agreements, send a Slack message.

Whenever the first one runs, it will activate the second one. This means the first automation sequence is the first level of the automation, and the second one is the second level. If the second automation set off another automation sequence, it would be the third level, and so on.

This is called an automation chain*, and they can only run seven (7) levels deep**. Automation chains that exceed this limitation may be blocked.

API Calls

API calls and Webhooks will both be measured separately from automation runs. Both will count as "API calls".

📘

API Rate Limit

Maximum of 10 API calls per second, 26,000,000 API calls per month, non-cumulative.

Are Add-on packages available? Only for the Enterprise plan.

The limits above are limits, not performance guarantees:

🚧

Stress-induced limitations

Sometimes API calls may set off automations, or may even take a while to finish because they depend on external processes or manage heavy amounts of data. In these cases, it may not be possible to make 10 API calls in 1 second.

What's an API (Application programming interfaces) call?
APIs are a way for one program to communicate with another by establishing endpoints where programs can make requests (calls) to fetch or send data. APIs make integrations between different tools possible.

Every time one system (A) communicates with another (B) it's an "API call" or "API request". In every request (A to B, or B to A), you can send one (or many) parameters and one (or many) records at the same time.

In other words, every time a request is sent to a Jestor endpoint, it will count as 1 API call.

Example
Running the code snippet below would make an API call to https://documentation.api.jestor.com/object/list to get records/cards from the table "sample_table". So running it once would count as 1 API call.

curl --request POST \
     --url https://documentation.api.jestor.com/object/list \
     --header 'Authorization: Bearer MjE5NzEzYWM0OWU2N2M5cd014f3bd4MTYxNjYwNDg2NWMzM2Nl' \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --data '
{
     "object_type": "sample_table",
     "sort": "number_field desc",
     "page": 1,
     "size": "100"
}
'

It's important to note that the /object/list endpoint has a response limit of 200 records, so if you have 1,000 records in a table and call the endpoint 5 times in order to fetch them all, it would count as 5 API calls.

SDK Automation and Integration

• Jestor SDKs are essentially shortcuts to API endpoints, so that you can achieve the same results with less code. This means SDK methods are essentially API calls to specific endpoints, and using a method equals to 1 API call.

Webhooks

• There are two types of webhooks inside Jestor: Object and Function webhooks. Object webhooks are webhooks that, when activated, create a record directly in a table. As such, they are essentially public endpoints that you can activate or inactivate at will. This means activating an object webhook once equals to making 1 API call.

Table Size

Records per Table

Each row in a table is a record. There are multiple types of data views in Jestor that are based on tables. As such, you may also think of every card in a kanban as a record, or each line in a list.

It's important to note that views do not count as extra records. If you have a Sales table with 25 records, and activate a kanban view for it, you will still have 25 records total for that table. What counts is the total number of records in the table the views are based on.

📘

Records per table limit

The number of rows of the largest table will be the one that defines your current usage. It's a per-table limit and It's cumulative. If you add more records in different months on the same table, it'll take all of them into account.

Every plan has its own table limit. You can check it out here.

Are Add-on packages available? Yes.

Structural Size

As with any other relational database, our tables have structural size limitations. It can reach a structural limit of bytes of information depending on the number of columns, type of columns, and data in a row. It does not mean you can't have files exceeding this limit, because files are archived in different structures.

Reaching this limitation is common when you have too many columns in a single table. The solution for this problem is to redesign your process or data structure to use more than one table. All the connected table fields could be useful to spread the data into different tables. Thus, creating a much better data structure and best performing internal tool.

📘

Structural limit per table

You can have up to 60,000 bytes of structural data in a table row.

Are Add-on packages available? No.

Table Connections

Jestor is a relational database, you can connect different tables (1:N), (1:1) or (M:N). Every connected table, it's a table connection.

📘

Connection per table

You can have up to 50 different table connections pointing to the same table.

Are Add-on packages available? No.

Infinite Loop and Circular Recursion

Sometimes, automation sequences in automation chains may end up activating previously activated sequences. This means the automation will run indefinitely, as it will continue to circle back to previous steps.

We call these types of scenario infinite loops, or circular recursion, because if not stopped they will run forever.

A classic example would be something like:

• When a new record is created in Sales, create a record in Agreements.
• When a new record is created in Agreements, create a record in Sales.

As it is, whenever a record is created in either Sales or Agreements, an automation will create a record in the other table, and activate an automation that creates a record back in the original table. Because of this logical error, this sequence will never end on its own.

Infinite loops and circular recursion may hurt user experience as it tends to be resource draining and change data indefinitely. Depending on the nature of the recursion, Jestor may automatically block these automation sequences from continuing.

🚧

Recursiveness counts towards your rate limits

Regardless of whether the automation sequence is blocked or not, every automation run, API call, or any other rate limit affected by it will still count towards the usage of your account. This will hold true even if the automation is rolled back or causes errors, and the desired outcome the automation is not achieved.

Premium Features

Premium features are specific functionalities that are only available to a few plans. You can identify premium features by indicators such as identifying titles, descriptions, "premium" banners at the bottom of a feature icons, or any other sort of graphical symbols that may denote the feature is Premium.

The image below is an example of what a "premium" banner may look like:

Add-on Features

Add-on features are system features that should be purchased in addition to a plan.

Users

There's no limit on the number of users per account. Members are free and Builders depend on your plan.

WhatsApp Messages (Beta)

We'll have a rate limit and different pricing once the feature upgrades from beta.

Bots Usage

Bots are computer programs that simulate human behavior.

❗️

It's forbidden. Adding bots on Jestor is against the terms of use

You can't try to simulate human usage using bots. If a bot is detected, the user will be excluded and the account may be blocked.

Data Imports from Connector

You can import spreadsheets to Jestor, automatically creating new records and fields.

📘

Number of Records Imported Rate Limit

Every import has a limit of 7500 cells from a spreadsheet.

Are Add-on packages available? No.

Storage

There are two types of storage limits in Jestor: single files and table storage.

• *Single files: the maximum size of a single file that you upload to Jestor, for example, images or PDFs. For any plan, the maximum size allowed is 100MB.
• *Table storage: the combined size of all files uploaded to a single table or page. For example, if you have a Proposals table with 5 records, and each record has a 5MB PDF file, the total storage used for that table is 25MB. for example images or PDFs. Every plan has its own table storage limit. You can check it out here

Hitting rate limits

If you hit any of the rate limits, you may be blocked from performing actions related to said limit.

For example:

• If you have a limit of 5,000 automation runs and run 5,000 automations in a month, automations will not be set off again until the following month or you expand your limits through add-ons or changing plans.
• If you have a limit of 25,000 records per table and hits a total of 25,000 in a table, you will not be able to create new records until you delete pre-existing records, or you expand your limits through add-ons or changing plans.

🚧

Plan ahead and don't lose data!

If you hit your account's rate limits, you may end up losing data or halting processes because of blocked features or functionalities. Those will not run retroactively. Unblocking will only affect future actions.

It is your responsibility to have the correct add-ons, plans or overall usage behavior that fits your operational needs.