Limits

Every limit that applies to your apps, builds, and account, in one place.

Plan limits come from your organization's plan. They are plan settings, not fixed rules, and they can change. Run deplane whoami --json to see the limits that apply to you right now. To see what you used against them, open Usage in the dashboard or run deplane usage; see Dashboard. To raise a limit, email support@deplane.io.

Requests to your app

Limit	Value
Request body	100 MB per HTTP request to an app.
Time to the first response byte	125 seconds. If your app sends nothing for 125 seconds after a request arrives, the request fails with a timeout. Send long work to a background job, or stream the response.
WebSockets	Supported, with no extra configuration. Connections stay open as long as data flows. Long-idle connections may be closed, so reconnect when that happens.
HTTPS	Every app gets `https://NAME.deplane.app` with a certificate, set up for you.
Large media	Deplane is not a host for large video or file downloads. Use a storage service for those.

Instance sizes

Size	CPU	Memory	Local disk
small (default)	0.5 vCPU	512 MB	1 GB
medium	1 vCPU	1 GB	2 GB
large	2 vCPU	2 GB	4 GB

Every instance of an app has the same size. Change it with deplane scale --size medium.

Local disk per instance

Each instance has a local disk of its own for the files it writes outside a disk: files anywhere in its file system, such as /tmp or a cache folder, and its log output. It is temporary: it starts empty at every deploy, restart or move to another server. Workers, cron jobs, release commands and runs get the local disk of their size. Databases, Redis, MySQL and ClickHouse keep their data on their own storage, which this limit does not count.

An instance that writes more than its local disk is stopped. A web or worker instance is then started again; a cron job's or a run's ends. A worker whose instances are stopped this way 3 times in 10 minutes is stopped altogether: start it again with deplane deploy, or with deplane processes scale (a larger size gives it more local disk). deplane status and deplane logs say so: "An instance was stopped at Oct 31 14:02 UTC because it wrote more than its local disk allows (1 GB)." Keep large or lasting files on a disk or in object storage, or use a larger size.

Deplane is turning this limit on team by team. Until it applies to your team, an instance's local disk is bounded only by its server's free space, which other teams share.

An autoscaled app counts at its maximum instances, whether or not it runs that many, and a sleeping app counts too.

Plans

New teams start on Free. Free is available today. Hobby ($7/month), Pro ($20/month) and Team ($99/month) are not on sale yet: Deplane can set them on request, at support@deplane.io. Enterprise is priced on request. See pricing.

Apps, people and domains:

Limit	Free	Hobby	Pro	Team	Enterprise	Error when you reach it
Memory, all instances of all apps together	1 GB	1.5 GB	3 GB	16 GB	64 GB	limit_memory
Apps	1	5	20	Unlimited	Unlimited	limit_apps
Instances, all apps together	2	3	10	40	300	limit_instances
Sizes	small	small, medium	small, medium, large	small, medium, large	small, medium, large	limit_size
App disk space, all disks together (disks are 5 GB each)	5 GB	10 GB	50 GB	250 GB	1000 GB	limit_disk
Members, counting open invitations	1	1	10	Unlimited	Unlimited	limit_members
Custom domains, all apps together	3	5	25	100	Unlimited	limit_domains
Pull request previews	No	Yes	Yes	Yes	Yes	limit_previews
Sleep when idle (web instances)	Apps sleep after 15 idle minutes (5 or 15)	Optional	Optional	Optional	Optional	limit_sleep
Workers (cron jobs are on every plan)	No	Yes	Yes	Yes	Yes	limit_sleep

Databases, builds and logs:

Limit	Free	Hobby	Pro	Team	Enterprise	Error when you reach it
Postgres databases (preview databases do not count)	1	2	5	15	50	limit_databases
Redis (256 MB memory each, counted in your memory)	1	1	3	10	25	limit_redis
MySQL (each counts as one instance of its size)	0	1	3	10	25	limit_mysql
ClickHouse databases (each counts as one large instance, 2 GB)	0	0	0	2	5	limit_clickhouse
Database backups kept (point-in-time restore to any second in them)	1 day	7 days	14 days	30 days	90 days	none
Build time, per month (reset on the 1st, UTC)	500 minutes	1000 minutes	2000 minutes	6000 minutes	20000 minutes	limit_build_minutes
Builds at the same time	1	1	2	4	8	none, more builds wait in the queue. Today the platform runs one build at a time for everyone; the higher numbers apply once more build capacity is added.
Live log streams at the same time	2	3	5	10	20	limit_log_streams
Assistant requests, per month	100	300	1000	3000	10000	assistant_monthly_limit
Log retention (planned)	7 days	14 days	30 days	60 days	365 days	none

Builds at the same time also share Deplane's build capacity with every other team. When it is busy, a build waits in the queue even below your plan's number. The queue is fair between teams: the team whose last build started longest ago goes first, and when several builds run at once, one team never holds them all.

Unlimited is a safety cap of 1000. Log retention is planned and not applied yet: today deplane logs shows the recent lines of each running instance, and build logs are kept 30 days.

A team moved to a smaller plan keeps its apps, members, databases and domains. Only new ones over the smaller plan's limits are refused. A team moved to Free keeps each app's sleep setting and its workers too. Scaling them down or removing them always works, as long as the same command does not ask for --sleep off or --sleep 60m; starting or growing an app needs sleep at 5 or 15 minutes, and a worker cannot be started or grown.

Backups are the exception. On a plan with a shorter backup window, backups older than the new window are deleted at the next hourly cleanup, and so are deleted databases (with their backups) that were deleted longer ago than the new window. Disk, Redis, MySQL and ClickHouse backups follow the shorter window too. This cannot be undone: restore anything you need first.

Beta (older teams)

Teams that joined during the beta stay on the Beta plan until Deplane moves them. Beta allows 1536 MB of memory, 3 apps, 3 instances, all three sizes, 10 GB of disk space, unlimited members, 30 custom domains and pull request previews.

Its data stores and builds: 5 Postgres databases, 1 Redis, 1 MySQL, 1 ClickHouse database (it needs 2048 MB, so it does not fit in Beta's memory), database backups kept 7 days, 300 build minutes a month, 1 build at a time, 3 live log streams and 300 assistant requests a month.

Memory counts every instance at its size. For example, Free's 1 GB holds two small instances (512 MB each), but not one medium and one small (1.5 GB). Pro's 3 GB holds one large instance (2 GB) and two small ones.

Errors for plan limits have codes that start with limit_, and the CLI exits with code 6 for them.

Besides your plan's limits, Deplane refuses a new app, a preview, a scale-up, a new or bigger worker or cron job, a new or restored database, a new Redis, a new MySQL, a new ClickHouse database, or a template deploy while its servers are nearly full (above 85% of their memory or CPU reserved), with capacity_full. Running apps keep running; try again later.

Redis

Limit	Value
Size	256 MB memory (200 MB of data), 1 GB storage
Redis per app	1. See redis_attached_elsewhere.
Back up now	Once an hour per Redis. See backup_too_soon.
Backups	Nightly; kept 3 days (or your plan's backup window, if shorter), plus the newest that worked; off-site, 7 days.

See Redis.

MySQL

Limit	Value
Sizes	medium (1 GB memory, 1 vCPU; the default) or large (2 GB, 2 vCPU). No small. See invalid_mysql_size.
Plan	A MySQL counts as one instance of its size, in your instances and your memory, like an app instance.
Storage	10 GB, on one of the platform's database disks, shared with Postgres. When none is free: database_capacity.
Connections	100 (medium) or 200 (large).
MySQL per app	1. See mysql_attached_elsewhere.
Back up now	Once an hour per MySQL. See backup_too_soon.
Backups	Nightly; kept 3 days (or your plan's backup window, if shorter), plus the newest that worked; off-site, 7 days. No point-in-time restore.

See MySQL.

ClickHouse

Limit	Value
Size	large only (2 GB memory, 2 vCPU). See invalid_clickhouse_size.
Plan	A ClickHouse database counts as one large instance, in your instances and your memory, like an app instance. It needs 2 GB of your plan's memory.
Storage	10 GB, on one of the platform's database disks, shared with Postgres and MySQL. When none is free: database_capacity.
Data	Keep it under about 4.5 GB: above that, backups and restores are refused for lack of room. See restore_no_room.
Queries	32 at once; about 840 MB of memory and 5 minutes each.
ClickHouse databases per app	1. See clickhouse_attached_elsewhere.
Back up now	Once an hour per ClickHouse database. See backup_too_soon.
Backups	Nightly; at most 2 kept (the newest that worked, plus the one before it for up to 3 days); off-site, 7 days. No point-in-time restore.

See ClickHouse.

Uploads and builds

Limit	Value
Upload size	100 MB compressed.
Project size	2 GiB uncompressed.
Files	200,000 files and folders.
Dockerfile	1 MB. A `# syntax=` line is not allowed.
Uploads at the same time	2 per organization.
Build time	15 minutes per build.
Build memory	3 GB.
Build disk	10 GB.
Image layer	2 GB compressed per layer.
Queue time	A build that waits in the queue for more than 1 hour expires. Run `deplane deploy` again.
Build logs	Kept 30 days.

The CLI never uploads the .git folder or .env files. It honors .gitignore and .dockerignore. Keep node_modules, build output, and large data files out of the upload with them.

Releases and rollout

Limit	Value
Time for a release to become healthy	5 minutes. After that the release fails with `Timeout` and the previous release keeps serving.
Startup	An instance has up to 2 minutes to start answering its health check.
Releases shown by `deplane releases`	The newest 50.
Release command	15 minutes, at the app's size. `deplane deploy` waits up to 15 minutes longer when there is one.
Runs (`deplane run`)	1 hour each; 2 at once per app and 5 per team; 30 per team per hour. Release commands and runs together: 2 at once per team. The output stays 1 hour after the run ends.

Databases

Limit	Value
Databases per team	Your plan's: 1 on Free, up to 50 on Enterprise. See limit_databases.
Disk per database	10 GB for each of its two copies.
Disk slots	A database uses two of the platform's database disks (one per copy), a preview database one. When no pair is free, a new database is refused with database_capacity.
Size	`small`, `medium`, or `large`; a database counts against your plan as one instance of its size.
Databases per app	1, as `DATABASE_URL`.
Backup window	Your plan's: 1 day on Free, 7 on Hobby, 14 on Pro. Restore to any second in it, up to about a minute ago.
Deleted databases	Restorable for the backup window, then deleted for good with their backups.
Importing a database	The source can be at most 5 GB; one active import per team; 20 checks a day per team; a live import is cancelled after 14 days of syncing. See Import a Postgres database.
Preview databases	3 per team at a time, smallest size, free (they do not count toward your plan's databases or limits). Never backed up.

See Databases.

App disks

Limit	Value
Disks per app	1, of 5 GB. See disk_exists.
Disk space per team	Your plan's: 5 GB on Free (one disk), 10 GB on Hobby. See limit_disk.
Instances of an app with a disk	1, without autoscaling. See disk_needs_one_instance.
Back up now	Once an hour per disk. See backup_too_soon.
Disk backups	Nightly. Disk backups are kept 3 days (or your plan's backup window, if shorter), plus the newest that worked; off-site, 7 days.

See Disks.

Apps, previews, domains, and processes

Limit	Value
Pull request previews	3 per app at a time, on plans that include them (not Free). They count toward your plan's apps and instances. Choose which pull requests get them: GitHub. See limit_previews.
Custom domains	10 per app, and your plan's for the whole team (3 on Free). See too_many_domains and limit_domains.
Workers and cron jobs	10 per app; a worker runs 0 to 20 instances.
Instances of one app	Up to your plan's instance limit. The autoscale maximum is 1 to 1000, also bound by your plan. The AI tools' `scale` tool takes at most 20 for `instances`.
Sleep when idle	After 5, 15, or 60 minutes without requests, or never. On Free, after 5 or 15 minutes, and new apps start at 15. See limit_sleep.
Automatic rollback	Watches a release for its first 10 minutes live. Needs at least 50 requests and 10 errors from the app (502, 503 and 504 do not count), reaching visitors on at least 3 networks.
Alert channels	10 per team.

Stacks

Limit	Value
`stack.yaml`	256 KB, one YAML document, nested at most 32 levels deep, with at most 200 aliases. See stack_too_large and stack_too_complex.
Services per stack	64
Engines (databases) per stack	64
Workers and cron jobs per app	10
Custom domains per app	10
Engines per app	One of each kind (Postgres, MySQL, Redis, ClickHouse).
Generated values	16 to 128 characters.
Steps in one apply	2000
Checks, plans and applies	30 per team per 10 minutes (the API's check, plan and apply calls); `deplane stack check` counts only when logged in, when it plans. See too_many_stack_plans.
Applies at the same time	1 per stack.
A new database becoming ready during an apply	15 minutes. See stack_timeout.

A stack's apps and databases count toward your plan's limits like any others. See Stacks.

Logs

Limit	Value
`deplane logs`	The last 100 lines of each running instance by default.
`deplane logs --tail N`	Up to 1000 lines per instance.
Live stream (`deplane logs -f`)	Up to 30 minutes per stream; run it again to continue.
Live streams at the same time	Set by your plan: 2 on Free, 3 on Hobby. A deploy that follows its build log uses one too.

Rate limits

What	Limit
Login, sign-in links, and second-factor attempts	5 per minute per IP address and per email
Access requests and abuse reports	3 per hour per IP address
API requests	120 per minute per token
Deploys	10 per hour per app
Live log streams	Your plan's number per organization at the same time (2 on Free)

When you hit a rate limit, the API answers HTTP 429 with rate_limited and a Retry-After header. Wait and try again.

API

Limit	Value
Request body	64 KB, except source uploads (100 MB) and stack checks, plans and applies (1 MB).
CLI login token	Lasts 30 days.
CI token	90 days by default, at most 365 days.
Login code (`deplane login`)	Expires after 10 minutes.
Fresh passkey confirmation	Valid for 5 minutes.

App names

3 to 40 characters.
Lowercase letters, digits, and single hyphens.
Start with a letter, and do not end with a hyphen.
Names are unique across Deplane. A destroyed app's name becomes free again.
Some names are reserved for Deplane, such as api, www, admin, login, docs, status, and support.
Names that contain a well-known brand are refused, to protect people from phishing. paypal-login and my-google-app are refused. Common letter swaps such as paypa1 count too. If you own the brand, email support@deplane.io.

Secrets

Limit	Value
Name	Capital letters, digits, and underscores; not starting with a digit; at most 128 characters.
Reserved names	`PORT` and names that start with `DEPLANE_`.
One value	32 KB.
All values of one app, per kind (runtime or build)	256 KB.

Network from your app

Your app can reach the internet. Some destinations are blocked for everyone:

Outbound email on port 25 is blocked. Use an email provider's API, or its submission port 587 or 465, which are rate limited.
Private networks, cloud metadata addresses, and Deplane's own servers are blocked.
Outbound TCP to the ports cryptocurrency mining pools commonly use (3333, 4444, 5555, 7777, 9999, 14444 and 45700) is blocked.

Regions

Apps run in one region today: fra (Frankfurt, Germany).

This page is also available as Markdown. AI agents can start at /llms.txt.