Limits

Each plan sets how much a workspace can hold and how much it can serve. When you reach most limits, we refuse only the thing that would go over it, and whatever is already running keeps running. Storage, the database limit and Free’s monthly usage are different: past them, apps that are running can stop too. Their sections below say which apps, and for whom.

Plan limits

Limit	Free	Team	Business	Enterprise
Apps per workspace	3	25	200	200
Members per workspace	3	25	200	200
Container apps per workspace	None	1	4	4
Container sizes	None	lite, basic	lite, basic, standard-1	lite, basic, standard-1
Containers per app	None	1	4	4
Container units	None	10	40	40
CPU time per request to a Worker app	50 ms	100 ms	150 ms	150 ms
Subrequests per request to a Worker app	50	50	50	50
Bypass tokens per app	5	50	100	100
Environment variables per app	25	50	100	100
Public paths per app	3	10	10	10
Custom domains per workspace	None	3	5	5
Pull requests’ previews at once	3	10	25	25
Postgres connections per workspace, up to	None	3	10	10
Apps with key-value storage	None	5	25	25
Apps with a queue	None	5	25	25
Storage per workspace: site files, app files, key-value data and databases	1 GB	10 GB	100 GB	100 GB
Databases per workspace, within its storage	1 GB of 1 GB	2 GB of 10 GB	10 GB of 100 GB	10 GB of 100 GB
Key-value data per workspace, within its storage	None	10 GB of 10 GB	10 GB of 100 GB	10 GB of 100 GB
Image pushes per workspace per day	None	20 GB	100 GB	100 GB
Requests included	100,000 a month	2,000,000 a month	20,000,000 a month	Set in your contract
After the included requests	Apps stop at 200,000	$3.78 per million	$3.78 per million	Apps keep running. Your contract settles it
CPU time	50,000,000 ms a month, then apps stop	Charged past what the plan includes	Charged past what the plan includes	Set in your contract. Apps keep running
Database rows read	50,000,000 a month, then apps stop	Charged past what the plan includes	Charged past what the plan includes	Set in your contract. Apps keep running
Database rows written	100,000 a month, then apps stop	Charged past what the plan includes	Charged past what the plan includes	Set in your contract. Apps keep running
Default usage limit	Not charged	$0 a month	$0 a month	None
Invoiced early at	Not charged	$100 of usage	$400 of usage	As your contract says
Audit log kept	3 months	3 months	12 months	12 months
Usage insights look back	30 days	90 days	365 days	365 days
People-and-app pairs insights count per day	500	1,000	2,500	2,500
App logs readable for	1 day	7 days	7 days	7 days
App log lines per workspace per day	20,000	100,000	300,000	300,000
Log drains per workspace	None	2	5	5
Log drain data per workspace per day	None	100 MB	100 MB	100 MB
SSO with SAML or OIDC	None	None	Early access	Included
SCIM provisioning	None	None	Early access	Included
Custom roles	None	None	Early access	Included
Publish policy	None	None	Early access	Included
Audit log export as CSV	None	None	Early access	Included
Audit log streaming to a SIEM	None	None	Early access	Included
Audit log streams per workspace	None	None	1	3
Private networks and fixed outbound addresses	None	None	None	Included
Your own encryption key	None	None	None	Included

On Free and Enterprise, a month is the calendar month in UTC. On Team and Business, it’s your billing month, which starts on the day you subscribed. An owner can change the usage limit or remove it.

Postgres connections and private networks aren’t switched on yet, on any plan. Their rows say what each plan gets once they are. Until then, connecting a database is refused with postgres_off, and making a network with not_found.

Single sign-on, SCIM, custom roles, the publish policy, the audit log’s CSV and streaming the audit log are Enterprise features. They’re included on Business for early customers, for a limited time. Your own encryption key is Enterprise’s alone.

Enterprise has every other limit Business has, and 3 audit log streams to Business’s 1. Its contract can also run more container apps, bigger sizes, more containers an app and more container units. See Container apps and sizes. What it includes of requests, CPU time and database rows is set in your contract, and nothing stops when you go past it. See Enterprise past its allowances.

The workspace’s Billing tab shows where you stand against each of these. Plans and billing covers prices, what each plan includes and what counts.

The database limit is part of your storage, not extra. Storage is 1 GB, 10 GB or 100 GB for site files, app files, key-value data and databases together, and the databases and key-value data can each use only their share of it.

The database limit

Your Worker apps’ databases together can hold up to the plan’s database limit. Cloudflare D1 can’t cap a database below 10 GB, so we measure each database every few minutes and act on that. A database can go past the limit before its apps are paused, usually by about ten minutes of writes, and by more when Cloudflare’s analytics are down.

Once your databases are over the limit:

• Apps with a database answer only the workspace’s owners and admins, signed in as themselves in a browser or with the CLI. That way they can delete rows through the app. Members, viewers, bypass tokens, public paths and webhooks get 507. Apps without a database keep answering everyone.
• Nothing new deploys in the workspace.
• If the databases keep growing, or reach 10% over the limit, apps with a database answer no one, owners and admins included.

To get back under, delete rows with forculus db exec or through the app, export data and remove it, or upgrade. On Free, deletes you run with forculus db exec while you’re over the limit don’t count toward your database rows, up to a monthly cap. The apps answer again within a minute of a measurement that finds you back under.

On Team and Business, storage over the limit costs $1.55 per GB-month, charged by the hour for as long as it lasts.

On Free, or while a workspace’s payments have lapsed, a workspace still over after 7 days is suspended. If it’s still over 30 days after that, we delete its largest databases, one at a time, until it’s under. Owners get an email 1 day and 5 days after the workspace goes over, with the date it will be suspended. They get another 7 days and 1 day before any database is deleted, naming the databases. Export first.

Owners get an email when the databases reach 80% of the limit, when they go over, when owners’ and admins’ access ends, and when they’re back under.

You can’t downgrade if it would leave the databases over the new plan’s limit. A cancellation that would do this isn’t refused, but owners get a warning 7 days and 1 day before the renewal.

Free’s CPU time

A Free workspace stops for the rest of the calendar month at 50,000,000 ms of CPU time, across all its Worker apps. Every app then answers 402 with the “Paused for the month” page. They start again when the month ends, or as soon as the workspace moves to a paid plan. Owners get an email at 80% and again when the apps stop.

CPU time is what Cloudflare records for each request: the time your code runs, not the time it waits on a fetch or the database. Container apps and static sites don’t count.

Our meter runs a few minutes behind, so a workspace can go a little past 50,000,000 ms before its apps stop. The count starts at the beginning of the month, or when the workspace moved to Free if that was later. The Billing tab shows where you stand.

If we can’t count a Free workspace’s CPU time for two hours, its Worker apps answer 402 with the page “Usage can’t be checked” until we can. Static sites keep answering.

Free’s database rows

A Free workspace stops for the rest of the calendar month at 50,000,000 database rows read or 100,000 written, whichever comes first. Every app then answers 402 with the “Paused for the month” page. Owners get an email at 80% of either limit and again when the apps stop.

Cloudflare counts the rows for each database. A query counts every row it reads, including rows it scans but doesn’t return, and every row and index entry it writes. That includes queries made while serving public paths, database exports and forculus db commands. We use the lowest figure Cloudflare’s analytics give, so the count never runs ahead of what you used.

Deleting to get back under the database limit

To get back under the database limit you have to delete rows, and a delete writes a row for every row it removes. So while your databases are over the limit, what a forculus db exec delete reads and writes doesn’t count toward these limits. That includes the delete that brings you back under.

Each month this covers 500,000,000 rows read and 1,000,000 rows written. A workspace that moved to Free holding more than Free allows gets one row written for every 32 bytes it was over when it moved, if that’s more. Only data that fit in the old plan’s limit counts. A workspace that moved 1 GB over gets 33,554,432 rows written.

Also:

• Each index entry a delete removes is a row written too, so deleting from a table with indexes uses the allowance faster.
• Growing after you go over doesn’t raise the exemption. In a later month, we work it out again from what is still over.
• Past the exemption, a delete counts like any other query.
• Rows your apps read and write always count, over the limit or not. So does a delete made through an app.
• A workspace already stopped for its rows can still delete with forculus db exec.

If we can’t measure a Free workspace’s rows for two hours, its apps that have a database answer 402 with the page “Usage can’t be checked” until we can. Apps without a database keep answering.

Enterprise past its allowances

On Enterprise, your contract sets how many requests, how much CPU time and how many database rows read and written a calendar month includes. Where it doesn’t set one, it’s what Business includes, except CPU time, which is 1,000,000,000 ms.

Going past an allowance doesn’t pause your apps, and there’s no usage limit to reach. Your contract says how usage over it is settled. The workspace’s Billing tab shows each allowance against what’s been used this month, and so do forculus billing show and forculus workspace usage. We see the same figures.

The other limits still apply: a request still has its CPU time and subrequests, and databases still stop at the database limit.

Subrequests

A request to a Worker app can make at most 50 subrequests on every plan. Subrequests are fetches and other outgoing calls, as Cloudflare counts them. We set the number on the app’s Worker, and Cloudflare holds to it exactly: the call past it throws Too many subrequests, which your code can catch. If your code doesn’t catch it, the request ends with an error, and the app’s log has the message.

Cloudflare’s message also points you at wrangler’s configuration for this limit. Ignore that: we set the limit, and a limits key in wrangler.jsonc does nothing.

Worker apps can’t use ctx.exports (loopback bindings) to call themselves.

When a paid workspace’s apps pause

On Team and Business, your apps answer 402 when:

• usage charges reach the usage limit. By default the limit is $0, so nothing beyond the plan’s price is charged, and your apps pause when the plan’s allowances run out. Usage charges never go past your usage limit. If you lower it partway through an hour, that hour still counts against the higher limit. Usage is measured a little after it happens, so some can run past the limit before the apps stop, and that usage is on us. They answer again when the billing month ends, or as soon as an owner raises or removes the limit on the Billing tab.
• an invoice during the month isn’t paid. They answer again once it is.
• you reach what the plan includes of CPU time or database rows before we’ve finished setting up billing for them on your subscription. We finish it ourselves, usually within the hour, and they answer again once it’s done. See Usage and charges.

Everyone in the workspace sees why on every page of the dashboard, and owners get an email. Plans and billing has the prices.

When you reach a limit

Creating one more of something fails with the plan_limit error. The message names the limit and the plan that allows more, and the CLI adds where to upgrade:

forculus app create acme/four

error: This workspace has 3 apps. The Free plan allows 3. Delete one or upgrade. Team allows 25 apps. Billing: https://app.forculuslabs.tech/w/acme/billing

With --json, the error includes the code, for scripts:

{"error":{"code":"plan_limit","message":"This workspace has 3 apps. The Free plan allows 3. Delete one or upgrade. Team allows 25 apps. Billing: https://app.forculuslabs.tech/w/acme/billing"}}

The API answers 403 with the limit’s details. The dashboard uses them to offer an upgrade:

{"error":"plan_limit","message":"That's 4 public paths, and the Free plan allows 3 per app. Team allows 10 public paths per app.","limit":{"what":"public_paths_per_app","max":3,"plan":"free"}}

what	Refused when you
apps	create an app past the limit
members	add a member past the limit. Changing a role doesn’t count.
container_apps	create or deploy a container app on Free, or one more than the plan allows
container_sizes	deploy a container at a size the plan doesn’t run
container_instances	deploy or scale a container app to more containers than the plan runs an app
container_units	deploy, roll back, scale or restore a container app past the units the plan’s container apps share. A change that doesn’t make the app use more than it does now is never refused for this.
tokens_per_app	create a token while the app has as many live ones as the plan allows
env_vars_per_app	set a variable that would take the app past the limit
public_paths_per_app	open a public path past the limit
custom_domains	add a custom domain past the workspace’s limit
postgres_connections	connect a Postgres database past the workspace’s limit. If the workspace moves to a plan with fewer, apps reach only its oldest connections, as many as the new plan allows.
log_drains	add a log drain, or turn one back on, past the workspace’s limit, or on Free
kv_apps	deploy an app that asks for key-value storage for the first time, past the workspace’s limit, or on Free
queue_apps	deploy an app that asks for a queue for the first time, past the workspace’s limit, or on Free
pull_request_previews	put up a preview for one more pull request than the plan allows at once
storage_bytes	upload site files, or deploy anything, past the workspace’s storage
kv_bytes	write a key past the share of storage key-value data may take
database_bytes	deploy anything while the workspace’s databases are past the plan’s limit, or move to a plan whose limit they don’t fit
sso	prove a domain, set or change the identity provider, or require it, on a plan without single sign-on
scim	make a SCIM token, have your provider add a user or keep one active, or make, rename or fill a group, on a plan without SCIM
roles	make a custom role, widen one, or give one to a member or a group, on a plan without custom roles
publish_policy	add a publish rule or tighten one, on a plan without a publish policy
audit_export	download the audit log as CSV on a plan without it
audit_stream	add an audit log stream on a plan without streaming
audit_streams	add an audit log stream past the workspace’s limit
private_network	add a private network, make a token for its connector, add a service to it, or give an app one of its services, on a plan without private networks
insights_days	ask for usage insights further back than the plan looks
customer_keys	add your own encryption key on a plan without it

Each refusal goes in the audit log as plan.limit, naming the limit.

Moving to a smaller plan takes nothing away at once. Anything already past a new limit stays, but you can’t add more until you’re back within it.

Container apps on Free

Free runs JavaScript, TypeScript and static apps. A container app is refused:

error: The Free plan only runs JS and static apps. Container apps, like Python, Go, Rust and Node servers, need a paid plan. Team runs container apps. Upgrade the workspace at https://app.forculuslabs.tech/w/acme/billing

If a workspace with a container app moves to Free, the app stops answering. The edge shows a page titled “This app needs a paid plan”, with status 402, until the workspace is on Team or Business again.

The same goes for a Worker app with key-value storage or a queue: Free has neither, so the app stops answering until the workspace is on a paid plan again. Its keys stay for 30 days, then are deleted, a week after the owners are told. Free also has no Postgres connections or log drains, so apps stop reaching the workspace’s Postgres databases, and its drains stop sending. After 30 days on Free, the connections come off Cloudflare, and go back on when the workspace moves back.

Container apps and sizes

Each plan runs a set number of container apps, at sizes up to a set one, with up to a set number of containers each. Together they can use up to the plan’s container units: each container uses its size’s units, so an app uses its size’s units times its containers.

	Team	Business
Container apps	1	4
Sizes	lite, basic	lite, basic, standard-1
Containers per app	1	4
Container units	10	40

Size	vCPU	Memory	Disk	Units
lite	1/16	256 MiB	2 GB	4
basic	1/4	1 GiB	4 GB	10
standard-1	1/2	4 GiB	8 GB	24
standard-2	1	6 GiB	12 GB	41
standard-3	2	8 GiB	16 GB	68
standard-4	4	12 GiB	20 GB	121

So Business runs four basic apps, or one app on four basic containers, or a standard-1 app beside a basic one and a lite one. More than one container explains how an app’s containers share its requests.

Creating one more container app, deploying at a bigger size, or asking for more containers or units than the plan has, is refused before anything is built:

forculus deploy acme/api ./api --instance-type standard-1

error: The Team plan runs lite and basic, and standard-1 is bigger. Deploy at one of those sizes with --instance-type, or upgrade. Business runs sizes up to standard-1. Billing: https://app.forculuslabs.tech/w/acme/billing

forculus scale acme/api 2

error: The Team plan runs up to 1 container an app, and this asks for 2. Run 1 or fewer, or upgrade. Business runs up to 4 containers an app. Billing: https://app.forculuslabs.tech/w/acme/billing

The same goes for a rollback to a version at a size the plan doesn’t run, or one that would take the workspace past its units. It also goes for a deploy that doesn’t give a size, when the live version runs at a size the plan doesn’t. A deploy that keeps an app at what it uses already is never refused for units, so a workspace that moved to a smaller plan keeps deploying what it runs. A container app in the bin uses no units, and restoring it needs room for what it ran.

You can’t move down to a plan that runs fewer or smaller container apps, fewer containers an app or fewer units, until the workspace fits it. First delete the extra apps, deploy them at a size the smaller plan runs, or run fewer containers with forculus scale. While a move down waits for the renewal, any container app you create, deploy or scale has to fit the smaller plan. If a workspace has more container apps than its plan runs, the oldest keep deploying and the rest wait for room.

On Enterprise, the contract can set more of each, up to standard-4 and 20 containers an app. It never sets less than Business. For more than Business runs, write to sales@forculuslabs.tech.

How the container limits are set

Cloudflare bills a container for every second it’s awake, busy or not, and each container has a Durable Object in front of it, billed the same way. These limits keep the cost of a workspace’s containers under the plan’s price, even if every container runs flat out all month. Here’s the cost of one container over a 730-hour month at Cloudflare’s prices (Containers pricing, Durable Objects pricing and instance types, all read 12 October 2026). Memory is $0.0000025 per GiB-second, disk $0.00000007 per GB-second, CPU busy the whole time $0.000020 per vCPU-second, and the Durable Object $12.50 per million GB-seconds at 128 MB, which is $4.11 a month:

Size	Memory	Disk	CPU	A month	Units	Its units’ worth
lite	$1.64	$0.37	$3.29	$9.40	4	$9.82
basic	$6.57	$0.74	$13.14	$24.55	10	$24.55
standard-1	$26.28	$1.47	$26.28	$58.14	24	$58.92
standard-2	$39.42	$2.21	$52.56	$98.29	41	$100.66
standard-3	$52.56	$2.94	$105.12	$164.73	68	$166.95
standard-4	$78.84	$3.68	$210.24	$296.87	121	$297.08

A unit is a tenth of basic, $2.4552 a month at most, and each size takes as many units as it costs, rounded up. So on the costs in this table, a workspace using all its units costs no more than its units at that rate, whatever sizes and numbers of containers it uses them on: Team’s 10 units at most $24.55, and Business’s 40 at most $98.21. Those are the one basic container and the four that Team and Business ran before they had units. The table leaves out the requests to each container’s Durable Object, its traffic out and the calls it makes, which cost about the same at any size. Counted in, many small containers cost a little more than a few big ones. A lite container comes to $10.32 a month at most, or $2.58 a unit, so ten lite containers on Business cost $1.33 a month more than the four basic it ran before. Each plan’s price still covers its containers at its limits. On Enterprise, units past Business are priced in the contract.

Storage

Your storage holds your site files, your apps’ own files and their databases together. Every file any version uploaded counts until the app is deleted. Apps’ own files count as we last measured them, every five minutes. Each database counts at its size when we last measured it, which we do about once an hour.

An upload that would take you past your storage is refused. Databases can still grow past it, because Cloudflare D1 has no limit below 10 GB a database. Once you’re past your storage, nothing new deploys in the workspace until you’re back under. That covers Workers, sites, containers and rollbacks:

error: This workspace's files and databases use 1.5 GB, over the 1 GB the Free plan allows, so nothing new deploys until it's back under. Delete rows from its apps' databases or files from its sites, or upgrade. Team allows 10 GB of storage. Billing: https://app.forculuslabs.tech/w/acme/billing

If any app in the workspace keeps files of its own, every app with a place for files stops too: it answers 507 to everyone, owners and admins included, until there’s room, because nothing else would stop it writing more. Every Worker and container app has a place for files, so only static sites keep serving. Make room with forculus files rm and forculus db exec, or upgrade. If the workspace stays over because of its apps’ files, we delete those files after 7 days on Free and 30 on Team and Business. If no app keeps files, going over storage only stops new deploys, and apps keep answering unless their databases are over the database limit. The Billing tab shows your storage and how much of it is databases, and tells you when you’re past it. Moving to a plan with less storage can put you past it too, with the same result.

CPU time

Each request to a Worker app can use a set amount of CPU time. The table above lists it by plan. Only the time your code is running counts, not time spent waiting on a fetch or the database. A server-rendered page usually takes a few tens of milliseconds. Work that needs more belongs in a container app.

We set the plan’s number on the app’s Worker. Cloudflare enforces it loosely: a request over it may finish or may be stopped, and you can’t tell which in advance. Keep each request under it. How far over it Cloudflare lets a request go isn’t fixed, and it can be a long way: a request can run to a few seconds of CPU time before it’s stopped. So the limit is no guard against a slow request. Your code has to be one.

A request Cloudflare stops for its CPU time or its memory gets 503 with error code: 1102. It’s your app’s error, not ours, so it has no X-Forculus-From header. The app’s log has what it printed before it stopped.

When the plan changes, every Worker app in the workspace gets the new CPU limit within about five minutes.

A static site runs none of your code. A container app isn’t held to this limit. Its size sets its CPU, and the Worker in front of it is ours.

Image pushes

Each container image you push counts against two budgets: the workspace’s daily budget in the table above, and 20 GB a day per person on any plan. Both are rolling, so a push counts for 24 hours. A push that would go over either is refused, and the image already deployed keeps running:

error: Couldn't upload a layer: you've used today's push budget. It frees up as pushes from the last 24 hours age out.

App logs

What your apps print goes into their logs, up to the plan’s lines a day across all the workspace’s apps, counted from midnight UTC. Past that, logging stops until midnight. The apps keep running. forculus logs and the app’s Logs tab tell you when logging has stopped.

Cloudflare keeps every line for 7 days, whatever the plan. The plan sets how far back you can read them: 1 day on Free and 7 days on Team and Business.

How the log limits are set

Cloudflare charges $0.60 a million lines past what our account includes (Workers Logs and Workers pricing, read 25 September 2026). It doesn’t limit how much one request prints, so the daily limit is what keeps a workspace’s logs under its price. At the limit every day for a month, Free writes 608,000 lines ($0.36), Team 3,040,000 ($1.82) and Business 9,120,000 ($5.47).

When a workspace runs out of requests

A Free workspace keeps serving past its 100,000 included requests, up to twice that: 200,000 in the calendar month, in UTC. After that, every request to its apps gets 402 and this page from the edge:

Paused for the month

The acme workspace has used what the Free plan includes this month: its requests, CPU time, or database rows read or written.

hello will answer again when the month starts over, or as soon as an owner moves the workspace to a paid plan in the dashboard.

Owners get an email when the workspace goes past its included requests, and another when its apps stop. An upgrade takes effect on the next request.

Enterprise workspaces never stop because of their request count either. See Enterprise past its allowances.

Team and Business workspaces never stop because of their request count. Requests past the allowance cost $3.78 per million, and the apps stop only at the usage limit. By default the limit is $0, so the apps stop when the allowance runs out unless an owner sets another.

The edge shows these pages only to people it would otherwise let in. Anyone else gets the usual refusal, so the pages tell strangers nothing about the workspace.

Status	Page title	Why
402	Paused for the month	A Free workspace served 200,000 requests this month, used 50,000,000 ms of CPU time, or its databases read 50,000,000 rows or wrote 100,000.
402	Paused at the usage limit	A Team or Business workspace reached its usage limit, or an allowance before we’d finished setting up billing for it, or an invoice during the month wasn’t paid. See when a paid workspace’s apps pause.
402	Usage can’t be checked	We couldn’t measure a Free workspace’s database rows, or count its CPU time, for two hours. Rows stop only apps with a database. CPU time stops only Worker apps that run code.
507	Storage over the limit	The workspace’s site files, app files, key-value data and databases together are over the plan’s storage, and at least one app keeps files or key-value data. Every app with a place for files or with key-value storage, for everyone. Apps with key-value storage also stop once the workspace’s key-value data is past its share of the storage.
507	Databases over the limit	The workspace’s databases are over the plan’s limit. Only apps with a database. Owners and admins still get in until the databases grow further.
402	This app needs a paid plan	A container app, or an app with key-value storage or a queue, in a workspace on Free.
403	App unavailable	The workspace has been suspended, or we’ve taken this app down.

Platform limits

These apply on every plan.

What	Limit
Workspaces one person owns	50. Workspaces you’re only a member of don’t count. Deleted ones you can still restore do.
Invitation emails	50 a day per workspace, and 100 a day per person across all their workspaces. A daily limit across all workspaces too, which leaves room for sign-in codes. Past any of them, access is still given and no email goes. See Members and invitations.
Emails about deleting and restoring	Up to 4 a day to an owner about one workspace being deleted or restored, 10 about one person’s doings and 20 in all, counted apart for new owners and other owners. Past a limit an email to a new owner isn’t sent. An owner who isn’t new gets the first of the day about each workspace whatever the limits, and a later one waits a day at most. A daily limit across everyone, past which they wait their turn, for up to 30 days. See Backups and restore.
Requests to public paths with no verifier	600 a minute per client IP address, or IPv6 /64, and open pattern, counted across every Cloudflare location. Paths an app hasn’t opened count together as one more pattern, counted at each location apart. Past a limit, 429 with Retry-After.
Public path patterns	200 characters each
Tokens that aren’t valid	60 a minute per client IP address, or IPv6 /64, counted across every Cloudflare location. Past that, the address’s tokens get 429 with Retry-After for a minute. See MCP servers.
Deliveries to a verified public path	Bodies up to 1 MiB, signature headers up to 4 KiB
Verified deliveries	Bursts of 600 per workspace, 300 of them to its busiest path, then 10 a second
How old a signed delivery can be	1 to 10 minutes. 5 unless you change it.
Webhook signing secrets	16 to 512 characters, or a whsec_ secret for Stripe and Standard Webhooks
An old signing secret after a rotation	Accepted for up to 7 days
Allowed email domains	20 per workspace
Bypass token lifetime	7, 30, 90 or 365 days from the dashboard. 1 to 30 days from the CLI, and no longer than the CLI session that made it. The API takes 1 to 365 days.
SCIM token lifetime	365 days. The workspace’s owners get an email 30 days and 7 days before it ends.
Audit log entries per call	500
Names of workspaces, apps and tokens	1 to 100 characters. No control characters and nothing invisible, like a zero-width space or a direction mark.
Workspace and app slugs	Up to 30 characters each, and 61 together
Workers bundle	32 MiB and 1,000 modules
Subrequests from one request to a Worker app	50 on every plan
Static site	20,000 files and 256 MiB per version, 25 MiB per file, 1 GiB stored per app
Environment variables	Names up to 64 characters, values up to 4,096 bytes. A container app’s variables must fit in 5,000 bytes together, as JSON.
Secret values	Up to 8,192 bytes
Versions you can roll back to	The newest 20, previews included, pull requests’ previews not
Previews	One per app at a time, for 7 days
Previews of pull requests	One per pull request, for 7 days at most. How many pull requests have one at a time is the plan’s, above.
Scheduled jobs	10 per app. Each workspace’s jobs get 20 runs a minute. A run has 30 seconds to answer.
Containers per app	Up to 20, Cloudflare’s default for an application, and no more than the plan runs. Each request goes to one of them.
Calls to apps’ databases from forculus db and the dashboard	600 an hour per workspace. A statement that writes is 2, a query that reads 1, a restore 2 or 3, showing where a restore to a time goes 1, and an export one for each second Cloudflare takes to make the dump. Everything but a restore stops at 540, so the last 60 are always there for restores. Showing where a restore goes is also limited to 60 an hour per app.
App files	25 MB a file from forculus files put or the dashboard, 100 MB from a container’s storage host. 30 forculus files calls a minute per workspace.
Database queries	1,000 rows a page, starting up to 100,000 rows in, 8 MB a page, 10,000 rows and 32 MB in a CSV. 15 seconds’ wait. 100 KB a statement. Shares the 30 calls a minute with forculus files, and counts toward the 600 calls an hour to apps’ databases above.
Domains an app is shared with	20 per app
Groups	100 per workspace, 500 people each, 50 per app
Agents	100 per workspace, 10 live credentials each, lasting up to 365 days
Custom domains added	20 an hour per workspace, on top of the plan’s limit
Projects looked up to import in the dashboard	20 an hour per person, and 60 per workspace
Hosts on an app’s outbound list	200
Workspace webhooks and Slack channels	10 per workspace together
AI client connections	50 per person, 3 from one client to one app. Each lasts 30 days.
GitHub Actions deploys	20 live credentials per app, each for 15 minutes. 10 new repositories saved an hour per person and per workspace.

We raise the workspace limit on request: write to support@forculuslabs.tech. Past it you see:

error: You already own 50 workspaces, the most one account can make. Deploy into one of those, or write to support@forculuslabs.tech to raise the limit.

When some of the 50 are deleted ones you can still restore, it says how to make room:

error: You already own 50 workspaces, the most one account can make, and 1 of them is a deleted one you can still restore. Delete one of those for good (`forculus workspace delete <workspace> --for-good` opens the page for it) to make room, deploy into one of the others, or write to support@forculuslabs.tech to raise the limit.

Next steps

• Plans and billing
• Tokens for scripts and machines
• Public paths and webhooks
• Containers