Make a database
A managed Postgres (reports/databases/README.md): a Drive (the data; in the strict tier unless storage.durability says standard: a commit returns once the object store has it) and an app of one stateful service whose instance mounts it, of the platform's Postgres image of the major version (ghcr.io/glacai/postgres-<version>), on the project's network under the database's name. The image makes the cluster on the empty Drive: the role group glac_superuser (the rights of Neon's neon_superuser; no superuser), the owner <database_name>_owner in it, the database; the owner's password is set once PostgreSQL is ready, as a SCRAM verifier, and is in this answer and kept nowhere. The call waits for the first start (150 s at the most) and answers the database ready (its instance's first start is over: PostgreSQL takes connections, the database is there, the owner has the password), or creating (it goes on: GET it). Idempotent by name: a create that names a database of the project answers that one, 200, without its password, where it asks for what it is. The app and the Drive are listed by /v1/apps and /v1/drives with managed_by, and changed through this API alone. A refusal of the Drive's or the app's create (the plan's limits, a name an app has) is the create's, and undoes what was made. Takes write. With tiering.enabled (a paid plan, where the object gateway serves), its branches load pg_lake and glac_tiering and run pgduck_server; where their partitions go and the key that reaches that prefix alone are handed to each running machine, never put in its start.
https://api.glac.ai/v1/databasesAutorisierung
AnfragetextJSONerforderlich
- sleep_after_secondsoptionalinteger | null
After how long with nothing asked of it its instance is paused, in seconds: from 1 (the default) to 3600 (an hour) on a paid plan. On Free 1, fixed: a Free plan's database is paused a second after its last query and sleeps five minutes later, as Neon's Free scales to zero; another value is refused 400
invalid_field.maximum: 3600 · minimum: 1 - suspend_after_secondsoptionalinteger | null
After how long paused its instance has its memory saved and sleeps, from 1 to 86400 (300, Neon's five minutes, where none is given): paused, it holds its sessions in memory and a connection is answered in a millisecond or two, its memory metered; asleep, only its storage is, and it still keeps its sessions. Its node holds it to the longest it holds any instance paused (ten minutes). On Free 300, fixed: another value is refused 400
invalid_field.maximum: 86400 · minimum: 1 - wake_daily_atoptionalstring | null
A time of day in UTC,
HH:MM, at which the database is woken every day while it rests, for what waits for a wake (pg_partman's maintenance, a vacuum that is due); it rests again once that is done. Itspg_cronjobs wake it at their own times whatever this says. Null (the default): none.pattern: ^([01][0-9]|2[0-3]):[0-5][0-9]$ - tieringoptionalobject | null
Tiered storage (DB18, Tiger's way): partitions of a table partitioned by range that a policy (
glac.add_tiering_policy) or a call (glac.tier_partition) moves become Parquet files in the platform's bucket of the project, still in the same table, read-only, read whereglac.enable_tiered_readsis on. On a paid plan alone (Free: 403paid_plan_required), where the object gateway serves (400objects_not_servedotherwise). Billed by their sizes before the move, $0.02 a GB-month (tiered_bytes); reading them is neither a request nor egress. - history_secondsoptionalinteger | null
How far back its root branch can be restored, or branched from, by a time, in seconds (slice DB8): a day unless the create said (
history_seconds), 0 (none) to 30 days on a paid plan, a day on Free (fixed, with a GB of old data at the most: its oldest versions go past it). The last day of it is its root branch's Drive's own window of versions, one every 30 seconds in which it was written (POST /v1/databases/{id}/branches/{branch}/restorewithat); further back, and to the second, is its WAL archive's (slice DB5:exact). Not billed: the history of a database's last day is free.maximum: 2592000 · minimum: 0
Returns
200
The database the name names, as the create asks for it: without its password.
- default_branchobjectrequired
A branch of a database: a stateful instance and a Drive. The root branch,
main, or one of the database's own (slice DB6): a fork of its parent's Drive.- statecreatingoderfailedoderawakeoderpausedoderasleepoderunavailable+2 weitererequired
Its instance's:
awakewhile it runs,pausedwhile the pause tier holds it in memory,asleepwhile it is saved;unavailablewhere its node cannot be reached (or it has no instance);creatingandfailedwhile the database has none yet, or failed to make one.deletinganddeletedwhile it is deleted, and once it is. - hoststring | nullrequired
Its public address, its endpoint under its database's region and the zone:
<endpoint>.<region>.<zone>(ep-calm-river-1a2b3c4d.na.db.glac.run), port 5432, TLS alone; where an edge serves PostgreSQL (the control plane's--database-zone), null where none does or the database has no region to be named under. - connection_uristring | nullrequired
How a client connects at its public address:
postgresql://<owner>@<host>/<database>?sslmode=require, with the owner's password in the answers that give it (a create, a reset) alone; a branch of its own has its parent's password; where an edge serves PostgreSQL (the control plane's--database-zone), null where none does or the database has no region to be named under. - storageobjectrequired
Its Drive (
GET /v1/drives/{drive_id}).- billed_bytesinteger | nullrequired
What its Drive is billed for keeping: what it holds, of the root branch; of a branch of its own, what it changed since the fork (what its newest version reads from objects of its own in the store, as the collector last worked it out), never more than what it holds: 0 until the collector said. Null before anything was said.
- start_commandrequired
How its server runs, as its instance's node says (the instance's
start_command,SandboxStartCommandinsandboxd/openapi/openapi.json):status(running;restarting: it ended, and is started again atrestarting_at;exited),restarts(how often it was started again in its machine after it ended, with its data as it was: PostgreSQL recovers by its WAL),last_exit(status,signal,at),restarting_at. Each start is also an eventinstance.restarted. Null where it has no instance, or its node said nothing of it yet.}Eines der folgenden:
- InstanceStartCommand
- statusstringrequired
running: a run of it is under way (or what it left behind still holds its output);restarting: it ended, and is started again atrestarting_at;exited: it ended, and nothing starts it again. - restartsintegerrequired
How often it was started again in its machine since the sandbox was made, across the boots of its machines.
format: int64 · minimum: 0 - last_exitrequired
How its last run ended; null where none has.
}Eines der folgenden:
- object
- null
- restarting_atstring | nullrequired
While
restarting: when its next run begins, by its guest's clock (a machine asleep then starts it as it wakes). Null otherwise.format: date-time
- null
- tieringobjectrequired
Tiered storage: whether it is on, and what it bills by now.
- tiered_bytesintegerrequired
What tiered storage bills by now: the sizes before the moves (
pg_table_sizeof each partition as it was swapped) of the files its branches point at as tiered, each file once however many branches point at it, and never less than what its prefix holds in the object store. 0 while nothing is tiered.
- history_secondsintegerrequired
How far back its root branch can be restored, or branched from, by a time (slice DB8): a day unless the create said (
history_seconds), 0 (none) to 30 days on a paid plan, a day on Free (fixed, with a GB of old data at the most: its oldest versions go past it). The last day of it is its root branch's Drive's own window of versions, one every 30 seconds in which it was written (POST /v1/databases/{id}/branches/{branch}/restorewithat); further back, and to the second, is its WAL archive's (slice DB5:exact). Not billed: the history of a database's last day is free.maximum: 2592000 · minimum: 0 - historyobjectrequired
Its history as it stands.
- fromstring | nullrequired
The earliest time its root branch can be restored to now, by its Drive's window or its WAL archive, whichever reaches further back (within
history_seconds); its making, where its WAL is archived (its archive's first base is the image's seed it started from); otherwise null until its Drive's window has a version (about three minutes after the database is ready).format: date-time - gapsArray vonobjectrequired
The gaps of its WAL archive within its history, the oldest first: where its archive's gateway refused its WAL so long that more of it waited than its Drive keeps for the log, and the WAL was given up so that the database stayed up. A time in one is restored only from its root branch's Drive's window (a whole minute, or a version's own time, while the window holds it); to the second or
exact, it is refused (400invalid_history), never taken from a version before it. Empty: none.
201
The database, ready (or creating, its first start under way), with the owner's password and the private connection string with it.
- default_branchobjectrequired
A branch of a database: a stateful instance and a Drive. The root branch,
main, or one of the database's own (slice DB6): a fork of its parent's Drive.- statecreatingoderfailedoderawakeoderpausedoderasleepoderunavailable+2 weitererequired
Its instance's:
awakewhile it runs,pausedwhile the pause tier holds it in memory,asleepwhile it is saved;unavailablewhere its node cannot be reached (or it has no instance);creatingandfailedwhile the database has none yet, or failed to make one.deletinganddeletedwhile it is deleted, and once it is. - hoststring | nullrequired
Its public address, its endpoint under its database's region and the zone:
<endpoint>.<region>.<zone>(ep-calm-river-1a2b3c4d.na.db.glac.run), port 5432, TLS alone; where an edge serves PostgreSQL (the control plane's--database-zone), null where none does or the database has no region to be named under. - connection_uristring | nullrequired
How a client connects at its public address:
postgresql://<owner>@<host>/<database>?sslmode=require, with the owner's password in the answers that give it (a create, a reset) alone; a branch of its own has its parent's password; where an edge serves PostgreSQL (the control plane's--database-zone), null where none does or the database has no region to be named under. - storageobjectrequired
Its Drive (
GET /v1/drives/{drive_id}).- billed_bytesinteger | nullrequired
What its Drive is billed for keeping: what it holds, of the root branch; of a branch of its own, what it changed since the fork (what its newest version reads from objects of its own in the store, as the collector last worked it out), never more than what it holds: 0 until the collector said. Null before anything was said.
- start_commandrequired
How its server runs, as its instance's node says (the instance's
start_command,SandboxStartCommandinsandboxd/openapi/openapi.json):status(running;restarting: it ended, and is started again atrestarting_at;exited),restarts(how often it was started again in its machine after it ended, with its data as it was: PostgreSQL recovers by its WAL),last_exit(status,signal,at),restarting_at. Each start is also an eventinstance.restarted. Null where it has no instance, or its node said nothing of it yet.}Eines der folgenden:
- InstanceStartCommand
- statusstringrequired
running: a run of it is under way (or what it left behind still holds its output);restarting: it ended, and is started again atrestarting_at;exited: it ended, and nothing starts it again. - restartsintegerrequired
How often it was started again in its machine since the sandbox was made, across the boots of its machines.
format: int64 · minimum: 0 - last_exitrequired
How its last run ended; null where none has.
}Eines der folgenden:
- object
- null
- restarting_atstring | nullrequired
While
restarting: when its next run begins, by its guest's clock (a machine asleep then starts it as it wakes). Null otherwise.format: date-time
- null
- tieringobjectrequired
Tiered storage: whether it is on, and what it bills by now.
- tiered_bytesintegerrequired
What tiered storage bills by now: the sizes before the moves (
pg_table_sizeof each partition as it was swapped) of the files its branches point at as tiered, each file once however many branches point at it, and never less than what its prefix holds in the object store. 0 while nothing is tiered.
- history_secondsintegerrequired
How far back its root branch can be restored, or branched from, by a time (slice DB8): a day unless the create said (
history_seconds), 0 (none) to 30 days on a paid plan, a day on Free (fixed, with a GB of old data at the most: its oldest versions go past it). The last day of it is its root branch's Drive's own window of versions, one every 30 seconds in which it was written (POST /v1/databases/{id}/branches/{branch}/restorewithat); further back, and to the second, is its WAL archive's (slice DB5:exact). Not billed: the history of a database's last day is free.maximum: 2592000 · minimum: 0 - historyobjectrequired
Its history as it stands.
- fromstring | nullrequired
The earliest time its root branch can be restored to now, by its Drive's window or its WAL archive, whichever reaches further back (within
history_seconds); its making, where its WAL is archived (its archive's first base is the image's seed it started from); otherwise null until its Drive's window has a version (about three minutes after the database is ready).format: date-time - gapsArray vonobjectrequired
The gaps of its WAL archive within its history, the oldest first: where its archive's gateway refused its WAL so long that more of it waited than its Drive keeps for the log, and the WAL was given up so that the database stayed up. A time in one is restored only from its root branch's Drive's window (a whole minute, or a version's own time, while the window holds it); to the second or
exact, it is refused (400invalid_history), never taken from a version before it. Empty: none.
400
invalid_json; unknown_field (of a later slice too: suspend_after_seconds, DB9; allowed_ips, DB3); missing_field: no name; invalid_name; unknown_version: a major version that is not offered (16, 17, 18); invalid_field (engine other than postgres, database_name, size, storage, sleep_after_seconds, metadata; history_seconds not 0 to 2592000, or not 86400 on Free); unknown_region; unknown_parameter. invalid_field of tiering.enabled (true or false), unknown_field of tiering.…. objects_not_served: tiering.enabled where this control plane has no object gateway.
- moveoptionalobject
With
move_over,move_going_backandmove_taken_over(POST /internal/moves/{id}/cancel): the move, as it stands.- stepstringrequired
Where it stands:
releasing(the old node is asked to release it; the table has it there),taking_over(the new node is asked to take it over; the table has it there),reclaiming(the new node refused it, and the old one is asked to take it back),restoring(the old one kept nothing of it, and takes it over from the object store),done(on the new node),failed(where it was, or back there, or where a failure no time clears or an operator's cancel found it:errorsays why).
- reportoptionalobject
With
compose_refused: the import's report, which says what is refused, why, and what to change.- itemsArray vonobjectrequired
The model's top-level elements:
name, each volume, network, config and secret, extensions.- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- servicesArray vonobjectrequired
The services the import takes, in the model's order.
- itemsArray vonobjectrequired
- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- appobjectrequired
The fields of the service's app as the import writes them: what its versions are made of, and what holds at once.
- sizeobjectrequired
What one instance may use at most. It is billed by what it uses.
- memory_bytesintegerrequired
An even number of MiB (a whole number of the 2 MiB pages a node loads a machine's memory in), in bytes. Any other size is 400
invalid_field(paramsize.memory_bytes): no node would make an instance of it, as none makes a sandbox of it (the node'sSandboxLimitsCreate.memory_bytes).minimum: 134217728
- scaleobjectrequired
- min_instancesintegerrequired
How many instances of the app are kept awake in a region, whether a request comes or not: the floor. The nodes of the region that serve the app share it as they share
max_instances(two nodes and a floor of 2: one on each; a floor of 1: one, on the node that is tried first; a floor of 5: three and two), and a node that is away is made up for by the others. A node makes its part when it is told, not at the first request, and neither stops nor deletes those instances for being idle; they are metered as instances that are awake. 0, which is what it is when nothing is said: none. Lowered, the instances beyond it are idle from that moment, and are stopped and deleted as idle instances are. At mostmax_instances, where that is given, and at most what the account's plan lets an app ask for in a region (caps.app_instances.limit: 5, 50 and 500): more is refused, 403plan_cap_reached.minimum: 0 - max_instancesinteger | nullrequired
How many instances the app has at the most in a region: the nodes of the region that serve the app share it. At most what the account's plan lets an app ask for (
caps.app_instances.limit: 5 on Free, 500 on Paid): more is refused, 403plan_cap_reached, and what an app asked for on a plan that let it is kept, and held to the plan's number.null: the plan's number for an app that names none (caps.app_instances.default: 2 on Free, 50 on Paid), ormin_instanceswhere that is more. What the nodes are told is no more than the account has room for awake beside everything else of it that is awake, nor less than the app has awake.minimum: 1 - concurrencyinteger | nullrequired
A cap on what one instance has in hand at a time: the requests the edges sent it, and the connections it has open on its project's network (through its service's address, which the node shares out among the instances connection by connection, or to its own). An instance with that many is full, and another is made for more.
null, which is what it is when nothing is said: no cap. A node then adds an instance when the ones it has are near their size in CPU or memory, and an app does not have to guess a number; a service that takes one request at a time gives one.maximum: 1000 · minimum: 1 - sleep_after_msinteger | nullrequired
The most an instance waits without a request before it stops, in milliseconds. Below it, its node picks the wait by the app's own traffic: the wait that would have cost least over the app's last gaps between a request's end and the next one, a second up and idle against a stop and the resume after it in CPU time, so that an app whose requests come closer together than a stop pays for stays up through them, and one whose requests are far apart stops as soon as its last answer has ended (
0: stops at once, always).null, which is what it is when nothing is said: the platform's most, three seconds. An app that said 100, the default before 2026-10-28, says null from then on. One that stays stopped is deleted by its node afterdelete_after_ms, and the next request that needs an instance gets a new one; the instancesmin_instanceskeeps awake are neither stopped nor deleted.maximum: 600000 · minimum: 0 - sleep_notice_msinteger | nullrequired
How long before an instance stops for being idle the programs connected to its guest's
/run/sbx/awakeare sent the linesleep N, in milliseconds: they flush what they hold, close their connections, or raise a hold, which puts the stop off. The stop comes that long after, whether they answer or not; where nobody is connected, it is not put off. A keyed instance is told as well. 0 or null: not told (the default).maximum: 60000 · minimum: 0 - sleep_hold_max_msintegerrequired
How long the holds a program in an instance raises keep it up after its time idle has run out, in milliseconds: a program connects to
/run/sbx/awakeand sends+before it answers a request whose work goes on after the answer, and-(or closes the connection, or dies) when that work is done; the instance stopssleep_after_msafter the last hold is lowered. Past this time it stops whatever holds it, the programs connected toldsleep N capfirst wheresleep_notice_msasks for a notice. Held, it runs and is metered as running. 0: holds are not heeded. Null: 30000 (the default).maximum: 900000 · minimum: 0 - delete_after_msinteger | nullrequired
After how long idle an instance is deleted, counted from where its stop is counted from: the next request that needs one gets a new instance, a clone of the version's template, without what the deleted one had gathered in its memory and on its disk (keep what is to last in a volume or a database). A second to an hour, the platform's time, which is the most: more is refused (400
invalid_field), and an instance that is to stay warm is one ofmin_instances.null, which is what it is when nothing is said: the hour of the nodes (--app-delete-after-seconds). A change holds for the instances the app has as for the ones made after: each node judges every instance by the app's time as it is, once a second at the least. Not for the app's keyed instances, whichkeys.delete_after_idle_msis for.maximum: 3600000 · minimum: 1000 - suspend_after_msoptionalinteger | null
How long a stopped instance stays paused before its memory is saved and it sleeps for real, in milliseconds: paused, the next request is answered in a millisecond or two and its memory is metered; asleep, it wakes in a few more and only what it keeps is. Its node holds it to the longest it holds any instance paused (ten minutes); the host's memory running short, a slot another machine needs and a sleep somebody asks for put it to sleep sooner. Null (the default): its node's longest. A database's
suspend_after_secondsis its app's.maximum: 86400000 · minimum: 1000 - wake_daily_atoptionalstring | null
A time of day in UTC,
HH:MM, at which the app's keyed instances and its stateful service's instance that rest are woken every day, for work of their own that waits for a wake (a database's maintenance, say); the instances the nodes make and delete by the app's requests are woken by requests alone. The wake is no activity: what runs then is, and once that is done the instance rests again. A stateful service's instance is woken besides for the next run of its PostgreSQL server'spg_cronjobs, whatever this says. Null (the default): none. A database'swake_daily_atis its app's.pattern: ^([01][0-9]|2[0-3]):[0-5][0-9]$
- egressobject | nullrequired
Egress rules as a sandbox has them (
default,allow,deny,http,inject), null when there are none; kept as the calls gave them (aPATCHmerges them key by key, as a node does). They hold at once and make no version: the nodes that serve the app put them on every instance of its group, the ones there are (one that runs for the connections it has too) and the ones made after; a keyed instance does not have them. The control plane checks only that they are an object of those keys of at most 256 KiB: what the rules say is a node's to check, when it applies them, and an instance whose rules its node cannot read is refused everything (the node's log says why).- deny_portsoptionalarray | null
Ports no connection reaches, TCP or UDP, wherever it goes and whatever else the rules say. A Browsers session's always hold 25, 465, 587 and the ports mining pools listen on (3333, 4444, 5555, 7777, 14444, 45700): the control plane adds them to whatever a change of its rules gives.
- runtimeoptional
Its runtime settings (
AppCreate.runtime).null: none.}Eines der folgenden:
- Runtime
- ulimitsMap vonRuntimeLimitGivenrequired
- sysctlsMap vonstringrequired
- tmpfsArray vonobjectrequired
- pathstringrequired
- size_bytesinteger | nullrequired
- modeintegerrequired
- dnsobjectrequired
- serversArray vonstringrequired
- searchArray vonstringrequired
- optionsArray vonstringrequired
- shm_size_bytesinteger | nullrequired
- null
401
missing_api_key, invalid_api_key, expired_api_key, invalid_token.
- moveoptionalobject
With
move_over,move_going_backandmove_taken_over(POST /internal/moves/{id}/cancel): the move, as it stands.- stepstringrequired
Where it stands:
releasing(the old node is asked to release it; the table has it there),taking_over(the new node is asked to take it over; the table has it there),reclaiming(the new node refused it, and the old one is asked to take it back),restoring(the old one kept nothing of it, and takes it over from the object store),done(on the new node),failed(where it was, or back there, or where a failure no time clears or an operator's cancel found it:errorsays why).
- reportoptionalobject
With
compose_refused: the import's report, which says what is refused, why, and what to change.- itemsArray vonobjectrequired
The model's top-level elements:
name, each volume, network, config and secret, extensions.- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- servicesArray vonobjectrequired
The services the import takes, in the model's order.
- itemsArray vonobjectrequired
- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- appobjectrequired
The fields of the service's app as the import writes them: what its versions are made of, and what holds at once.
- sizeobjectrequired
What one instance may use at most. It is billed by what it uses.
- memory_bytesintegerrequired
An even number of MiB (a whole number of the 2 MiB pages a node loads a machine's memory in), in bytes. Any other size is 400
invalid_field(paramsize.memory_bytes): no node would make an instance of it, as none makes a sandbox of it (the node'sSandboxLimitsCreate.memory_bytes).minimum: 134217728
- scaleobjectrequired
- min_instancesintegerrequired
How many instances of the app are kept awake in a region, whether a request comes or not: the floor. The nodes of the region that serve the app share it as they share
max_instances(two nodes and a floor of 2: one on each; a floor of 1: one, on the node that is tried first; a floor of 5: three and two), and a node that is away is made up for by the others. A node makes its part when it is told, not at the first request, and neither stops nor deletes those instances for being idle; they are metered as instances that are awake. 0, which is what it is when nothing is said: none. Lowered, the instances beyond it are idle from that moment, and are stopped and deleted as idle instances are. At mostmax_instances, where that is given, and at most what the account's plan lets an app ask for in a region (caps.app_instances.limit: 5, 50 and 500): more is refused, 403plan_cap_reached.minimum: 0 - max_instancesinteger | nullrequired
How many instances the app has at the most in a region: the nodes of the region that serve the app share it. At most what the account's plan lets an app ask for (
caps.app_instances.limit: 5 on Free, 500 on Paid): more is refused, 403plan_cap_reached, and what an app asked for on a plan that let it is kept, and held to the plan's number.null: the plan's number for an app that names none (caps.app_instances.default: 2 on Free, 50 on Paid), ormin_instanceswhere that is more. What the nodes are told is no more than the account has room for awake beside everything else of it that is awake, nor less than the app has awake.minimum: 1 - concurrencyinteger | nullrequired
A cap on what one instance has in hand at a time: the requests the edges sent it, and the connections it has open on its project's network (through its service's address, which the node shares out among the instances connection by connection, or to its own). An instance with that many is full, and another is made for more.
null, which is what it is when nothing is said: no cap. A node then adds an instance when the ones it has are near their size in CPU or memory, and an app does not have to guess a number; a service that takes one request at a time gives one.maximum: 1000 · minimum: 1 - sleep_after_msinteger | nullrequired
The most an instance waits without a request before it stops, in milliseconds. Below it, its node picks the wait by the app's own traffic: the wait that would have cost least over the app's last gaps between a request's end and the next one, a second up and idle against a stop and the resume after it in CPU time, so that an app whose requests come closer together than a stop pays for stays up through them, and one whose requests are far apart stops as soon as its last answer has ended (
0: stops at once, always).null, which is what it is when nothing is said: the platform's most, three seconds. An app that said 100, the default before 2026-10-28, says null from then on. One that stays stopped is deleted by its node afterdelete_after_ms, and the next request that needs an instance gets a new one; the instancesmin_instanceskeeps awake are neither stopped nor deleted.maximum: 600000 · minimum: 0 - sleep_notice_msinteger | nullrequired
How long before an instance stops for being idle the programs connected to its guest's
/run/sbx/awakeare sent the linesleep N, in milliseconds: they flush what they hold, close their connections, or raise a hold, which puts the stop off. The stop comes that long after, whether they answer or not; where nobody is connected, it is not put off. A keyed instance is told as well. 0 or null: not told (the default).maximum: 60000 · minimum: 0 - sleep_hold_max_msintegerrequired
How long the holds a program in an instance raises keep it up after its time idle has run out, in milliseconds: a program connects to
/run/sbx/awakeand sends+before it answers a request whose work goes on after the answer, and-(or closes the connection, or dies) when that work is done; the instance stopssleep_after_msafter the last hold is lowered. Past this time it stops whatever holds it, the programs connected toldsleep N capfirst wheresleep_notice_msasks for a notice. Held, it runs and is metered as running. 0: holds are not heeded. Null: 30000 (the default).maximum: 900000 · minimum: 0 - delete_after_msinteger | nullrequired
After how long idle an instance is deleted, counted from where its stop is counted from: the next request that needs one gets a new instance, a clone of the version's template, without what the deleted one had gathered in its memory and on its disk (keep what is to last in a volume or a database). A second to an hour, the platform's time, which is the most: more is refused (400
invalid_field), and an instance that is to stay warm is one ofmin_instances.null, which is what it is when nothing is said: the hour of the nodes (--app-delete-after-seconds). A change holds for the instances the app has as for the ones made after: each node judges every instance by the app's time as it is, once a second at the least. Not for the app's keyed instances, whichkeys.delete_after_idle_msis for.maximum: 3600000 · minimum: 1000 - suspend_after_msoptionalinteger | null
How long a stopped instance stays paused before its memory is saved and it sleeps for real, in milliseconds: paused, the next request is answered in a millisecond or two and its memory is metered; asleep, it wakes in a few more and only what it keeps is. Its node holds it to the longest it holds any instance paused (ten minutes); the host's memory running short, a slot another machine needs and a sleep somebody asks for put it to sleep sooner. Null (the default): its node's longest. A database's
suspend_after_secondsis its app's.maximum: 86400000 · minimum: 1000 - wake_daily_atoptionalstring | null
A time of day in UTC,
HH:MM, at which the app's keyed instances and its stateful service's instance that rest are woken every day, for work of their own that waits for a wake (a database's maintenance, say); the instances the nodes make and delete by the app's requests are woken by requests alone. The wake is no activity: what runs then is, and once that is done the instance rests again. A stateful service's instance is woken besides for the next run of its PostgreSQL server'spg_cronjobs, whatever this says. Null (the default): none. A database'swake_daily_atis its app's.pattern: ^([01][0-9]|2[0-3]):[0-5][0-9]$
- egressobject | nullrequired
Egress rules as a sandbox has them (
default,allow,deny,http,inject), null when there are none; kept as the calls gave them (aPATCHmerges them key by key, as a node does). They hold at once and make no version: the nodes that serve the app put them on every instance of its group, the ones there are (one that runs for the connections it has too) and the ones made after; a keyed instance does not have them. The control plane checks only that they are an object of those keys of at most 256 KiB: what the rules say is a node's to check, when it applies them, and an instance whose rules its node cannot read is refused everything (the node's log says why).- deny_portsoptionalarray | null
Ports no connection reaches, TCP or UDP, wherever it goes and whatever else the rules say. A Browsers session's always hold 25, 465, 587 and the ports mining pools listen on (3333, 4444, 5555, 7777, 14444, 45700): the control plane adds them to whatever a change of its rules gives.
- runtimeoptional
Its runtime settings (
AppCreate.runtime).null: none.}Eines der folgenden:
- Runtime
- ulimitsMap vonRuntimeLimitGivenrequired
- sysctlsMap vonstringrequired
- tmpfsArray vonobjectrequired
- pathstringrequired
- size_bytesinteger | nullrequired
- modeintegerrequired
- dnsobjectrequired
- serversArray vonstringrequired
- searchArray vonstringrequired
- optionsArray vonstringrequired
- shm_size_bytesinteger | nullrequired
- null
402
account_in_debt: the account owes (its balance is below zero), and until it has paid nothing of it can be used: every call of its keys, and of the tokens of its sandboxes, is refused so, but those that read what it owes and pay it; those that list and read the backups of its volumes and make a volume from one (POST /v1/volumes with from_backup, but while what it stores is being deleted), what one that stopped paying wants most; and, unless the control plane is started with --debt-allows-delete false, those that list, read and delete the volumes, snapshots and sandboxes it stores, and delete its backups. Never a new backup. Before the key's scopes are looked at, and whatever the path. The message says how much is owed, since when, when what the account stores is deleted, how to pay, that it can delete what it stores to stop the amount from growing, and that a volume is still made from a backup (GET /v1/billing, debt).
- moveoptionalobject
With
move_over,move_going_backandmove_taken_over(POST /internal/moves/{id}/cancel): the move, as it stands.- stepstringrequired
Where it stands:
releasing(the old node is asked to release it; the table has it there),taking_over(the new node is asked to take it over; the table has it there),reclaiming(the new node refused it, and the old one is asked to take it back),restoring(the old one kept nothing of it, and takes it over from the object store),done(on the new node),failed(where it was, or back there, or where a failure no time clears or an operator's cancel found it:errorsays why).
- reportoptionalobject
With
compose_refused: the import's report, which says what is refused, why, and what to change.- itemsArray vonobjectrequired
The model's top-level elements:
name, each volume, network, config and secret, extensions.- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- servicesArray vonobjectrequired
The services the import takes, in the model's order.
- itemsArray vonobjectrequired
- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- appobjectrequired
The fields of the service's app as the import writes them: what its versions are made of, and what holds at once.
- sizeobjectrequired
What one instance may use at most. It is billed by what it uses.
- memory_bytesintegerrequired
An even number of MiB (a whole number of the 2 MiB pages a node loads a machine's memory in), in bytes. Any other size is 400
invalid_field(paramsize.memory_bytes): no node would make an instance of it, as none makes a sandbox of it (the node'sSandboxLimitsCreate.memory_bytes).minimum: 134217728
- scaleobjectrequired
- min_instancesintegerrequired
How many instances of the app are kept awake in a region, whether a request comes or not: the floor. The nodes of the region that serve the app share it as they share
max_instances(two nodes and a floor of 2: one on each; a floor of 1: one, on the node that is tried first; a floor of 5: three and two), and a node that is away is made up for by the others. A node makes its part when it is told, not at the first request, and neither stops nor deletes those instances for being idle; they are metered as instances that are awake. 0, which is what it is when nothing is said: none. Lowered, the instances beyond it are idle from that moment, and are stopped and deleted as idle instances are. At mostmax_instances, where that is given, and at most what the account's plan lets an app ask for in a region (caps.app_instances.limit: 5, 50 and 500): more is refused, 403plan_cap_reached.minimum: 0 - max_instancesinteger | nullrequired
How many instances the app has at the most in a region: the nodes of the region that serve the app share it. At most what the account's plan lets an app ask for (
caps.app_instances.limit: 5 on Free, 500 on Paid): more is refused, 403plan_cap_reached, and what an app asked for on a plan that let it is kept, and held to the plan's number.null: the plan's number for an app that names none (caps.app_instances.default: 2 on Free, 50 on Paid), ormin_instanceswhere that is more. What the nodes are told is no more than the account has room for awake beside everything else of it that is awake, nor less than the app has awake.minimum: 1 - concurrencyinteger | nullrequired
A cap on what one instance has in hand at a time: the requests the edges sent it, and the connections it has open on its project's network (through its service's address, which the node shares out among the instances connection by connection, or to its own). An instance with that many is full, and another is made for more.
null, which is what it is when nothing is said: no cap. A node then adds an instance when the ones it has are near their size in CPU or memory, and an app does not have to guess a number; a service that takes one request at a time gives one.maximum: 1000 · minimum: 1 - sleep_after_msinteger | nullrequired
The most an instance waits without a request before it stops, in milliseconds. Below it, its node picks the wait by the app's own traffic: the wait that would have cost least over the app's last gaps between a request's end and the next one, a second up and idle against a stop and the resume after it in CPU time, so that an app whose requests come closer together than a stop pays for stays up through them, and one whose requests are far apart stops as soon as its last answer has ended (
0: stops at once, always).null, which is what it is when nothing is said: the platform's most, three seconds. An app that said 100, the default before 2026-10-28, says null from then on. One that stays stopped is deleted by its node afterdelete_after_ms, and the next request that needs an instance gets a new one; the instancesmin_instanceskeeps awake are neither stopped nor deleted.maximum: 600000 · minimum: 0 - sleep_notice_msinteger | nullrequired
How long before an instance stops for being idle the programs connected to its guest's
/run/sbx/awakeare sent the linesleep N, in milliseconds: they flush what they hold, close their connections, or raise a hold, which puts the stop off. The stop comes that long after, whether they answer or not; where nobody is connected, it is not put off. A keyed instance is told as well. 0 or null: not told (the default).maximum: 60000 · minimum: 0 - sleep_hold_max_msintegerrequired
How long the holds a program in an instance raises keep it up after its time idle has run out, in milliseconds: a program connects to
/run/sbx/awakeand sends+before it answers a request whose work goes on after the answer, and-(or closes the connection, or dies) when that work is done; the instance stopssleep_after_msafter the last hold is lowered. Past this time it stops whatever holds it, the programs connected toldsleep N capfirst wheresleep_notice_msasks for a notice. Held, it runs and is metered as running. 0: holds are not heeded. Null: 30000 (the default).maximum: 900000 · minimum: 0 - delete_after_msinteger | nullrequired
After how long idle an instance is deleted, counted from where its stop is counted from: the next request that needs one gets a new instance, a clone of the version's template, without what the deleted one had gathered in its memory and on its disk (keep what is to last in a volume or a database). A second to an hour, the platform's time, which is the most: more is refused (400
invalid_field), and an instance that is to stay warm is one ofmin_instances.null, which is what it is when nothing is said: the hour of the nodes (--app-delete-after-seconds). A change holds for the instances the app has as for the ones made after: each node judges every instance by the app's time as it is, once a second at the least. Not for the app's keyed instances, whichkeys.delete_after_idle_msis for.maximum: 3600000 · minimum: 1000 - suspend_after_msoptionalinteger | null
How long a stopped instance stays paused before its memory is saved and it sleeps for real, in milliseconds: paused, the next request is answered in a millisecond or two and its memory is metered; asleep, it wakes in a few more and only what it keeps is. Its node holds it to the longest it holds any instance paused (ten minutes); the host's memory running short, a slot another machine needs and a sleep somebody asks for put it to sleep sooner. Null (the default): its node's longest. A database's
suspend_after_secondsis its app's.maximum: 86400000 · minimum: 1000 - wake_daily_atoptionalstring | null
A time of day in UTC,
HH:MM, at which the app's keyed instances and its stateful service's instance that rest are woken every day, for work of their own that waits for a wake (a database's maintenance, say); the instances the nodes make and delete by the app's requests are woken by requests alone. The wake is no activity: what runs then is, and once that is done the instance rests again. A stateful service's instance is woken besides for the next run of its PostgreSQL server'spg_cronjobs, whatever this says. Null (the default): none. A database'swake_daily_atis its app's.pattern: ^([01][0-9]|2[0-3]):[0-5][0-9]$
- egressobject | nullrequired
Egress rules as a sandbox has them (
default,allow,deny,http,inject), null when there are none; kept as the calls gave them (aPATCHmerges them key by key, as a node does). They hold at once and make no version: the nodes that serve the app put them on every instance of its group, the ones there are (one that runs for the connections it has too) and the ones made after; a keyed instance does not have them. The control plane checks only that they are an object of those keys of at most 256 KiB: what the rules say is a node's to check, when it applies them, and an instance whose rules its node cannot read is refused everything (the node's log says why).- deny_portsoptionalarray | null
Ports no connection reaches, TCP or UDP, wherever it goes and whatever else the rules say. A Browsers session's always hold 25, 465, 587 and the ports mining pools listen on (3333, 4444, 5555, 7777, 14444, 45700): the control plane adds them to whatever a change of its rules gives.
- runtimeoptional
Its runtime settings (
AppCreate.runtime).null: none.}Eines der folgenden:
- Runtime
- ulimitsMap vonRuntimeLimitGivenrequired
- sysctlsMap vonstringrequired
- tmpfsArray vonobjectrequired
- pathstringrequired
- size_bytesinteger | nullrequired
- modeintegerrequired
- dnsobjectrequired
- serversArray vonstringrequired
- searchArray vonstringrequired
- optionsArray vonstringrequired
- shm_size_bytesinteger | nullrequired
- null
403
key_scope, needs_api_key, account_held (as everywhere); product_not_open: Serverless Database is not open on this platform yet (--products): nothing new of it is made. plan_cap_reached: the free plan's databases (param): databases, one more than the account may have (100); storage.size_bytes, one that would hold more than 1 GB (a free database's Drive is 1 GB, given where the create gives no size); account_database_cu_hours, the account's databases computed the free plan's 300 CU-hours this calendar month. paid_plan_required: tiering.enabled on the free plan.
- moveoptionalobject
With
move_over,move_going_backandmove_taken_over(POST /internal/moves/{id}/cancel): the move, as it stands.- stepstringrequired
Where it stands:
releasing(the old node is asked to release it; the table has it there),taking_over(the new node is asked to take it over; the table has it there),reclaiming(the new node refused it, and the old one is asked to take it back),restoring(the old one kept nothing of it, and takes it over from the object store),done(on the new node),failed(where it was, or back there, or where a failure no time clears or an operator's cancel found it:errorsays why).
- reportoptionalobject
With
compose_refused: the import's report, which says what is refused, why, and what to change.- itemsArray vonobjectrequired
The model's top-level elements:
name, each volume, network, config and secret, extensions.- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- servicesArray vonobjectrequired
The services the import takes, in the model's order.
- itemsArray vonobjectrequired
- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- appobjectrequired
The fields of the service's app as the import writes them: what its versions are made of, and what holds at once.
- sizeobjectrequired
What one instance may use at most. It is billed by what it uses.
- memory_bytesintegerrequired
An even number of MiB (a whole number of the 2 MiB pages a node loads a machine's memory in), in bytes. Any other size is 400
invalid_field(paramsize.memory_bytes): no node would make an instance of it, as none makes a sandbox of it (the node'sSandboxLimitsCreate.memory_bytes).minimum: 134217728
- scaleobjectrequired
- min_instancesintegerrequired
How many instances of the app are kept awake in a region, whether a request comes or not: the floor. The nodes of the region that serve the app share it as they share
max_instances(two nodes and a floor of 2: one on each; a floor of 1: one, on the node that is tried first; a floor of 5: three and two), and a node that is away is made up for by the others. A node makes its part when it is told, not at the first request, and neither stops nor deletes those instances for being idle; they are metered as instances that are awake. 0, which is what it is when nothing is said: none. Lowered, the instances beyond it are idle from that moment, and are stopped and deleted as idle instances are. At mostmax_instances, where that is given, and at most what the account's plan lets an app ask for in a region (caps.app_instances.limit: 5, 50 and 500): more is refused, 403plan_cap_reached.minimum: 0 - max_instancesinteger | nullrequired
How many instances the app has at the most in a region: the nodes of the region that serve the app share it. At most what the account's plan lets an app ask for (
caps.app_instances.limit: 5 on Free, 500 on Paid): more is refused, 403plan_cap_reached, and what an app asked for on a plan that let it is kept, and held to the plan's number.null: the plan's number for an app that names none (caps.app_instances.default: 2 on Free, 50 on Paid), ormin_instanceswhere that is more. What the nodes are told is no more than the account has room for awake beside everything else of it that is awake, nor less than the app has awake.minimum: 1 - concurrencyinteger | nullrequired
A cap on what one instance has in hand at a time: the requests the edges sent it, and the connections it has open on its project's network (through its service's address, which the node shares out among the instances connection by connection, or to its own). An instance with that many is full, and another is made for more.
null, which is what it is when nothing is said: no cap. A node then adds an instance when the ones it has are near their size in CPU or memory, and an app does not have to guess a number; a service that takes one request at a time gives one.maximum: 1000 · minimum: 1 - sleep_after_msinteger | nullrequired
The most an instance waits without a request before it stops, in milliseconds. Below it, its node picks the wait by the app's own traffic: the wait that would have cost least over the app's last gaps between a request's end and the next one, a second up and idle against a stop and the resume after it in CPU time, so that an app whose requests come closer together than a stop pays for stays up through them, and one whose requests are far apart stops as soon as its last answer has ended (
0: stops at once, always).null, which is what it is when nothing is said: the platform's most, three seconds. An app that said 100, the default before 2026-10-28, says null from then on. One that stays stopped is deleted by its node afterdelete_after_ms, and the next request that needs an instance gets a new one; the instancesmin_instanceskeeps awake are neither stopped nor deleted.maximum: 600000 · minimum: 0 - sleep_notice_msinteger | nullrequired
How long before an instance stops for being idle the programs connected to its guest's
/run/sbx/awakeare sent the linesleep N, in milliseconds: they flush what they hold, close their connections, or raise a hold, which puts the stop off. The stop comes that long after, whether they answer or not; where nobody is connected, it is not put off. A keyed instance is told as well. 0 or null: not told (the default).maximum: 60000 · minimum: 0 - sleep_hold_max_msintegerrequired
How long the holds a program in an instance raises keep it up after its time idle has run out, in milliseconds: a program connects to
/run/sbx/awakeand sends+before it answers a request whose work goes on after the answer, and-(or closes the connection, or dies) when that work is done; the instance stopssleep_after_msafter the last hold is lowered. Past this time it stops whatever holds it, the programs connected toldsleep N capfirst wheresleep_notice_msasks for a notice. Held, it runs and is metered as running. 0: holds are not heeded. Null: 30000 (the default).maximum: 900000 · minimum: 0 - delete_after_msinteger | nullrequired
After how long idle an instance is deleted, counted from where its stop is counted from: the next request that needs one gets a new instance, a clone of the version's template, without what the deleted one had gathered in its memory and on its disk (keep what is to last in a volume or a database). A second to an hour, the platform's time, which is the most: more is refused (400
invalid_field), and an instance that is to stay warm is one ofmin_instances.null, which is what it is when nothing is said: the hour of the nodes (--app-delete-after-seconds). A change holds for the instances the app has as for the ones made after: each node judges every instance by the app's time as it is, once a second at the least. Not for the app's keyed instances, whichkeys.delete_after_idle_msis for.maximum: 3600000 · minimum: 1000 - suspend_after_msoptionalinteger | null
How long a stopped instance stays paused before its memory is saved and it sleeps for real, in milliseconds: paused, the next request is answered in a millisecond or two and its memory is metered; asleep, it wakes in a few more and only what it keeps is. Its node holds it to the longest it holds any instance paused (ten minutes); the host's memory running short, a slot another machine needs and a sleep somebody asks for put it to sleep sooner. Null (the default): its node's longest. A database's
suspend_after_secondsis its app's.maximum: 86400000 · minimum: 1000 - wake_daily_atoptionalstring | null
A time of day in UTC,
HH:MM, at which the app's keyed instances and its stateful service's instance that rest are woken every day, for work of their own that waits for a wake (a database's maintenance, say); the instances the nodes make and delete by the app's requests are woken by requests alone. The wake is no activity: what runs then is, and once that is done the instance rests again. A stateful service's instance is woken besides for the next run of its PostgreSQL server'spg_cronjobs, whatever this says. Null (the default): none. A database'swake_daily_atis its app's.pattern: ^([01][0-9]|2[0-3]):[0-5][0-9]$
- egressobject | nullrequired
Egress rules as a sandbox has them (
default,allow,deny,http,inject), null when there are none; kept as the calls gave them (aPATCHmerges them key by key, as a node does). They hold at once and make no version: the nodes that serve the app put them on every instance of its group, the ones there are (one that runs for the connections it has too) and the ones made after; a keyed instance does not have them. The control plane checks only that they are an object of those keys of at most 256 KiB: what the rules say is a node's to check, when it applies them, and an instance whose rules its node cannot read is refused everything (the node's log says why).- deny_portsoptionalarray | null
Ports no connection reaches, TCP or UDP, wherever it goes and whatever else the rules say. A Browsers session's always hold 25, 465, 587 and the ports mining pools listen on (3333, 4444, 5555, 7777, 14444, 45700): the control plane adds them to whatever a change of its rules gives.
- runtimeoptional
Its runtime settings (
AppCreate.runtime).null: none.}Eines der folgenden:
- Runtime
- ulimitsMap vonRuntimeLimitGivenrequired
- sysctlsMap vonstringrequired
- tmpfsArray vonobjectrequired
- pathstringrequired
- size_bytesinteger | nullrequired
- modeintegerrequired
- dnsobjectrequired
- serversArray vonstringrequired
- searchArray vonstringrequired
- optionsArray vonstringrequired
- shm_size_bytesinteger | nullrequired
- null
409
name_taken: the project has a database of the name that is not what the create asks for, or an app or a Drive has the name (the Drive is <name>-data).
- moveoptionalobject
With
move_over,move_going_backandmove_taken_over(POST /internal/moves/{id}/cancel): the move, as it stands.- stepstringrequired
Where it stands:
releasing(the old node is asked to release it; the table has it there),taking_over(the new node is asked to take it over; the table has it there),reclaiming(the new node refused it, and the old one is asked to take it back),restoring(the old one kept nothing of it, and takes it over from the object store),done(on the new node),failed(where it was, or back there, or where a failure no time clears or an operator's cancel found it:errorsays why).
- reportoptionalobject
With
compose_refused: the import's report, which says what is refused, why, and what to change.- itemsArray vonobjectrequired
The model's top-level elements:
name, each volume, network, config and secret, extensions.- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- servicesArray vonobjectrequired
The services the import takes, in the model's order.
- itemsArray vonobjectrequired
- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- appobjectrequired
The fields of the service's app as the import writes them: what its versions are made of, and what holds at once.
- sizeobjectrequired
What one instance may use at most. It is billed by what it uses.
- memory_bytesintegerrequired
An even number of MiB (a whole number of the 2 MiB pages a node loads a machine's memory in), in bytes. Any other size is 400
invalid_field(paramsize.memory_bytes): no node would make an instance of it, as none makes a sandbox of it (the node'sSandboxLimitsCreate.memory_bytes).minimum: 134217728
- scaleobjectrequired
- min_instancesintegerrequired
How many instances of the app are kept awake in a region, whether a request comes or not: the floor. The nodes of the region that serve the app share it as they share
max_instances(two nodes and a floor of 2: one on each; a floor of 1: one, on the node that is tried first; a floor of 5: three and two), and a node that is away is made up for by the others. A node makes its part when it is told, not at the first request, and neither stops nor deletes those instances for being idle; they are metered as instances that are awake. 0, which is what it is when nothing is said: none. Lowered, the instances beyond it are idle from that moment, and are stopped and deleted as idle instances are. At mostmax_instances, where that is given, and at most what the account's plan lets an app ask for in a region (caps.app_instances.limit: 5, 50 and 500): more is refused, 403plan_cap_reached.minimum: 0 - max_instancesinteger | nullrequired
How many instances the app has at the most in a region: the nodes of the region that serve the app share it. At most what the account's plan lets an app ask for (
caps.app_instances.limit: 5 on Free, 500 on Paid): more is refused, 403plan_cap_reached, and what an app asked for on a plan that let it is kept, and held to the plan's number.null: the plan's number for an app that names none (caps.app_instances.default: 2 on Free, 50 on Paid), ormin_instanceswhere that is more. What the nodes are told is no more than the account has room for awake beside everything else of it that is awake, nor less than the app has awake.minimum: 1 - concurrencyinteger | nullrequired
A cap on what one instance has in hand at a time: the requests the edges sent it, and the connections it has open on its project's network (through its service's address, which the node shares out among the instances connection by connection, or to its own). An instance with that many is full, and another is made for more.
null, which is what it is when nothing is said: no cap. A node then adds an instance when the ones it has are near their size in CPU or memory, and an app does not have to guess a number; a service that takes one request at a time gives one.maximum: 1000 · minimum: 1 - sleep_after_msinteger | nullrequired
The most an instance waits without a request before it stops, in milliseconds. Below it, its node picks the wait by the app's own traffic: the wait that would have cost least over the app's last gaps between a request's end and the next one, a second up and idle against a stop and the resume after it in CPU time, so that an app whose requests come closer together than a stop pays for stays up through them, and one whose requests are far apart stops as soon as its last answer has ended (
0: stops at once, always).null, which is what it is when nothing is said: the platform's most, three seconds. An app that said 100, the default before 2026-10-28, says null from then on. One that stays stopped is deleted by its node afterdelete_after_ms, and the next request that needs an instance gets a new one; the instancesmin_instanceskeeps awake are neither stopped nor deleted.maximum: 600000 · minimum: 0 - sleep_notice_msinteger | nullrequired
How long before an instance stops for being idle the programs connected to its guest's
/run/sbx/awakeare sent the linesleep N, in milliseconds: they flush what they hold, close their connections, or raise a hold, which puts the stop off. The stop comes that long after, whether they answer or not; where nobody is connected, it is not put off. A keyed instance is told as well. 0 or null: not told (the default).maximum: 60000 · minimum: 0 - sleep_hold_max_msintegerrequired
How long the holds a program in an instance raises keep it up after its time idle has run out, in milliseconds: a program connects to
/run/sbx/awakeand sends+before it answers a request whose work goes on after the answer, and-(or closes the connection, or dies) when that work is done; the instance stopssleep_after_msafter the last hold is lowered. Past this time it stops whatever holds it, the programs connected toldsleep N capfirst wheresleep_notice_msasks for a notice. Held, it runs and is metered as running. 0: holds are not heeded. Null: 30000 (the default).maximum: 900000 · minimum: 0 - delete_after_msinteger | nullrequired
After how long idle an instance is deleted, counted from where its stop is counted from: the next request that needs one gets a new instance, a clone of the version's template, without what the deleted one had gathered in its memory and on its disk (keep what is to last in a volume or a database). A second to an hour, the platform's time, which is the most: more is refused (400
invalid_field), and an instance that is to stay warm is one ofmin_instances.null, which is what it is when nothing is said: the hour of the nodes (--app-delete-after-seconds). A change holds for the instances the app has as for the ones made after: each node judges every instance by the app's time as it is, once a second at the least. Not for the app's keyed instances, whichkeys.delete_after_idle_msis for.maximum: 3600000 · minimum: 1000 - suspend_after_msoptionalinteger | null
How long a stopped instance stays paused before its memory is saved and it sleeps for real, in milliseconds: paused, the next request is answered in a millisecond or two and its memory is metered; asleep, it wakes in a few more and only what it keeps is. Its node holds it to the longest it holds any instance paused (ten minutes); the host's memory running short, a slot another machine needs and a sleep somebody asks for put it to sleep sooner. Null (the default): its node's longest. A database's
suspend_after_secondsis its app's.maximum: 86400000 · minimum: 1000 - wake_daily_atoptionalstring | null
A time of day in UTC,
HH:MM, at which the app's keyed instances and its stateful service's instance that rest are woken every day, for work of their own that waits for a wake (a database's maintenance, say); the instances the nodes make and delete by the app's requests are woken by requests alone. The wake is no activity: what runs then is, and once that is done the instance rests again. A stateful service's instance is woken besides for the next run of its PostgreSQL server'spg_cronjobs, whatever this says. Null (the default): none. A database'swake_daily_atis its app's.pattern: ^([01][0-9]|2[0-3]):[0-5][0-9]$
- egressobject | nullrequired
Egress rules as a sandbox has them (
default,allow,deny,http,inject), null when there are none; kept as the calls gave them (aPATCHmerges them key by key, as a node does). They hold at once and make no version: the nodes that serve the app put them on every instance of its group, the ones there are (one that runs for the connections it has too) and the ones made after; a keyed instance does not have them. The control plane checks only that they are an object of those keys of at most 256 KiB: what the rules say is a node's to check, when it applies them, and an instance whose rules its node cannot read is refused everything (the node's log says why).- deny_portsoptionalarray | null
Ports no connection reaches, TCP or UDP, wherever it goes and whatever else the rules say. A Browsers session's always hold 25, 465, 587 and the ports mining pools listen on (3333, 4444, 5555, 7777, 14444, 45700): the control plane adds them to whatever a change of its rules gives.
- runtimeoptional
Its runtime settings (
AppCreate.runtime).null: none.}Eines der folgenden:
- Runtime
- ulimitsMap vonRuntimeLimitGivenrequired
- sysctlsMap vonstringrequired
- tmpfsArray vonobjectrequired
- pathstringrequired
- size_bytesinteger | nullrequired
- modeintegerrequired
- dnsobjectrequired
- serversArray vonstringrequired
- searchArray vonstringrequired
- optionsArray vonstringrequired
- shm_size_bytesinteger | nullrequired
- null
503
no_capacity (retryable): no node has room for the Drive, or none copies Drives to an object store (the strict tier).
- moveoptionalobject
With
move_over,move_going_backandmove_taken_over(POST /internal/moves/{id}/cancel): the move, as it stands.- stepstringrequired
Where it stands:
releasing(the old node is asked to release it; the table has it there),taking_over(the new node is asked to take it over; the table has it there),reclaiming(the new node refused it, and the old one is asked to take it back),restoring(the old one kept nothing of it, and takes it over from the object store),done(on the new node),failed(where it was, or back there, or where a failure no time clears or an operator's cancel found it:errorsays why).
- reportoptionalobject
With
compose_refused: the import's report, which says what is refused, why, and what to change.- itemsArray vonobjectrequired
The model's top-level elements:
name, each volume, network, config and secret, extensions.- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- servicesArray vonobjectrequired
The services the import takes, in the model's order.
- itemsArray vonobjectrequired
- treatmentdoneoderadaptedoderignoredoderrefusedrequired
done: it means the same on the platform;adapted: the platform does the same another way;ignored: it matters to a local run alone (refused withstrict);refused: the platform cannot do it, and doing without it would let the program go wrong quietly.
- appobjectrequired
The fields of the service's app as the import writes them: what its versions are made of, and what holds at once.
- sizeobjectrequired
What one instance may use at most. It is billed by what it uses.
- memory_bytesintegerrequired
An even number of MiB (a whole number of the 2 MiB pages a node loads a machine's memory in), in bytes. Any other size is 400
invalid_field(paramsize.memory_bytes): no node would make an instance of it, as none makes a sandbox of it (the node'sSandboxLimitsCreate.memory_bytes).minimum: 134217728
- scaleobjectrequired
- min_instancesintegerrequired
How many instances of the app are kept awake in a region, whether a request comes or not: the floor. The nodes of the region that serve the app share it as they share
max_instances(two nodes and a floor of 2: one on each; a floor of 1: one, on the node that is tried first; a floor of 5: three and two), and a node that is away is made up for by the others. A node makes its part when it is told, not at the first request, and neither stops nor deletes those instances for being idle; they are metered as instances that are awake. 0, which is what it is when nothing is said: none. Lowered, the instances beyond it are idle from that moment, and are stopped and deleted as idle instances are. At mostmax_instances, where that is given, and at most what the account's plan lets an app ask for in a region (caps.app_instances.limit: 5, 50 and 500): more is refused, 403plan_cap_reached.minimum: 0 - max_instancesinteger | nullrequired
How many instances the app has at the most in a region: the nodes of the region that serve the app share it. At most what the account's plan lets an app ask for (
caps.app_instances.limit: 5 on Free, 500 on Paid): more is refused, 403plan_cap_reached, and what an app asked for on a plan that let it is kept, and held to the plan's number.null: the plan's number for an app that names none (caps.app_instances.default: 2 on Free, 50 on Paid), ormin_instanceswhere that is more. What the nodes are told is no more than the account has room for awake beside everything else of it that is awake, nor less than the app has awake.minimum: 1 - concurrencyinteger | nullrequired
A cap on what one instance has in hand at a time: the requests the edges sent it, and the connections it has open on its project's network (through its service's address, which the node shares out among the instances connection by connection, or to its own). An instance with that many is full, and another is made for more.
null, which is what it is when nothing is said: no cap. A node then adds an instance when the ones it has are near their size in CPU or memory, and an app does not have to guess a number; a service that takes one request at a time gives one.maximum: 1000 · minimum: 1 - sleep_after_msinteger | nullrequired
The most an instance waits without a request before it stops, in milliseconds. Below it, its node picks the wait by the app's own traffic: the wait that would have cost least over the app's last gaps between a request's end and the next one, a second up and idle against a stop and the resume after it in CPU time, so that an app whose requests come closer together than a stop pays for stays up through them, and one whose requests are far apart stops as soon as its last answer has ended (
0: stops at once, always).null, which is what it is when nothing is said: the platform's most, three seconds. An app that said 100, the default before 2026-10-28, says null from then on. One that stays stopped is deleted by its node afterdelete_after_ms, and the next request that needs an instance gets a new one; the instancesmin_instanceskeeps awake are neither stopped nor deleted.maximum: 600000 · minimum: 0 - sleep_notice_msinteger | nullrequired
How long before an instance stops for being idle the programs connected to its guest's
/run/sbx/awakeare sent the linesleep N, in milliseconds: they flush what they hold, close their connections, or raise a hold, which puts the stop off. The stop comes that long after, whether they answer or not; where nobody is connected, it is not put off. A keyed instance is told as well. 0 or null: not told (the default).maximum: 60000 · minimum: 0 - sleep_hold_max_msintegerrequired
How long the holds a program in an instance raises keep it up after its time idle has run out, in milliseconds: a program connects to
/run/sbx/awakeand sends+before it answers a request whose work goes on after the answer, and-(or closes the connection, or dies) when that work is done; the instance stopssleep_after_msafter the last hold is lowered. Past this time it stops whatever holds it, the programs connected toldsleep N capfirst wheresleep_notice_msasks for a notice. Held, it runs and is metered as running. 0: holds are not heeded. Null: 30000 (the default).maximum: 900000 · minimum: 0 - delete_after_msinteger | nullrequired
After how long idle an instance is deleted, counted from where its stop is counted from: the next request that needs one gets a new instance, a clone of the version's template, without what the deleted one had gathered in its memory and on its disk (keep what is to last in a volume or a database). A second to an hour, the platform's time, which is the most: more is refused (400
invalid_field), and an instance that is to stay warm is one ofmin_instances.null, which is what it is when nothing is said: the hour of the nodes (--app-delete-after-seconds). A change holds for the instances the app has as for the ones made after: each node judges every instance by the app's time as it is, once a second at the least. Not for the app's keyed instances, whichkeys.delete_after_idle_msis for.maximum: 3600000 · minimum: 1000 - suspend_after_msoptionalinteger | null
How long a stopped instance stays paused before its memory is saved and it sleeps for real, in milliseconds: paused, the next request is answered in a millisecond or two and its memory is metered; asleep, it wakes in a few more and only what it keeps is. Its node holds it to the longest it holds any instance paused (ten minutes); the host's memory running short, a slot another machine needs and a sleep somebody asks for put it to sleep sooner. Null (the default): its node's longest. A database's
suspend_after_secondsis its app's.maximum: 86400000 · minimum: 1000 - wake_daily_atoptionalstring | null
A time of day in UTC,
HH:MM, at which the app's keyed instances and its stateful service's instance that rest are woken every day, for work of their own that waits for a wake (a database's maintenance, say); the instances the nodes make and delete by the app's requests are woken by requests alone. The wake is no activity: what runs then is, and once that is done the instance rests again. A stateful service's instance is woken besides for the next run of its PostgreSQL server'spg_cronjobs, whatever this says. Null (the default): none. A database'swake_daily_atis its app's.pattern: ^([01][0-9]|2[0-3]):[0-5][0-9]$
- egressobject | nullrequired
Egress rules as a sandbox has them (
default,allow,deny,http,inject), null when there are none; kept as the calls gave them (aPATCHmerges them key by key, as a node does). They hold at once and make no version: the nodes that serve the app put them on every instance of its group, the ones there are (one that runs for the connections it has too) and the ones made after; a keyed instance does not have them. The control plane checks only that they are an object of those keys of at most 256 KiB: what the rules say is a node's to check, when it applies them, and an instance whose rules its node cannot read is refused everything (the node's log says why).- deny_portsoptionalarray | null
Ports no connection reaches, TCP or UDP, wherever it goes and whatever else the rules say. A Browsers session's always hold 25, 465, 587 and the ports mining pools listen on (3333, 4444, 5555, 7777, 14444, 45700): the control plane adds them to whatever a change of its rules gives.
- runtimeoptional
Its runtime settings (
AppCreate.runtime).null: none.}Eines der folgenden:
- Runtime
- ulimitsMap vonRuntimeLimitGivenrequired
- sysctlsMap vonstringrequired
- tmpfsArray vonobjectrequired
- pathstringrequired
- size_bytesinteger | nullrequired
- modeintegerrequired
- dnsobjectrequired
- serversArray vonstringrequired
- searchArray vonstringrequired
- optionsArray vonstringrequired
- shm_size_bytesinteger | nullrequired
- null