Set the account's spend limit, or its plan
spend_limit_usd. The most the control plane takes from the account's card by itself in a calendar month (auto reload, and what is owed, on the billing day), for every month from now on; null takes the limit away. Auto reload makes no top-up with which what the card was charged by itself in the month (what failed, and what was taken back, left out) would come to more than the limit: with a limit of $45 and reloads of $20 there are two in a month. The charge of what an account in debt owes, on its billing day, is no more than what the limit leaves, and auto reload counts it in turn. A top-up the account asks for itself is not counted, and is not held back. The limit stops nothing by itself. A limit that is raised, or taken away, lets auto reload make its top-up with this call. For an account that has never topped up there is no auto reload, and the limit holds nothing. An account that never chose one has its plan's (spend_limit_usd of GET /internal/control plans: $50 on Paid, none on Free, as the control plane is started by default).
plan. paid: the account subscribes. A charge of Paid's fee, $5, is made (GET /v1/billing/charges, kind: subscription), and the account is on Paid, in a period with Paid's quantities whole, from the moment it is collected; the same call again makes no second charge. free ends the subscription at the end of the period that is paid for; paid asked for before that end takes the ending back. An account that is no business, where only businesses are sold to, may not ask for Paid: 403 tax_region_business_only, before anything of the call is done (control/README.md, 税). 409 subscription_charge_pending: free while a charge of the subscription (its first period's, or its next one's) is being collected, which cannot be taken back and, collected, would begin the period the account says it does not want.
Takes admin.
https://api.glac.ai/v1/billingAutoryzacja
Treść żądaniaJSONwymagane
- planoptionalfreelubpaid
paid: the account subscribes to Paid, $5 a month: the charge of its first period is made at once (GET /v1/billing/charges,kindsubscription), and it is on Paid from the moment it is collected; asked while a subscription that is to end goes on, it goes on after all, and nothing is charged.free: the subscription ends at the end of the period that is paid for, and nothing is paid back; until then the account is on Paid. - start_nowoptionalboolean
Of a
planthat is bought now (the account has no subscription that goes on, or moves up):true: the account asks for what it buys to be provided at once, within the 14 days in which a consumer in the European Economic Area or the United Kingdom may withdraw from it, and acknowledges that it pays for what was provided if it withdraws and that a top-up whose Credits are all used has been provided in full and can no longer be withdrawn from (GET /v1/billing/withdrawals,right.start_now, has the words). Required of an account that buys as a consumer there (no tax id that is verified or being verified, and its billing address there, or, without one, the address the call comes from): 400start_now_requiredwithout it. Kept with the purchase wherever it is given: without it, a withdrawal gives back all that was paid (control/README.md, 撤回).
Returns
200
The account's billing, as it is now.
- metersobjectrequired
- cpuobjectrequired
One meter of the stretch the account is in (
included_fromtoincluded_to): a period of its subscription on Paid, or the day (UTC) on Free.- unitcpu_mslubmemory_gib_secondslubrequestslubvolume_data_gb_hourslubegress_byteslubvolume_cache_gb_hours+4 więcejrequired
What the quantities are in. Of a period of Paid: CPU-ms (milliseconds of a busy vCPU), GiB-seconds of memory, requests, GB-hours of volume data and of the NVMe cache, bytes sent, GB-hours of logs kept. Of Free's day, what its quotas count: the same of CPU, memory, requests and traffic; of volume data and of the cache the bytes kept at once (
volume_data_bytes,volume_cache_bytes: a level, as the last whole hour's books have it); of the logs the bytes printed in the day (log_bytes). - includednumber | nullrequired
What the stretch includes of the meter: Paid's quantity for the period (of volume data, of its cache and of the logs, the GB that may be kept for the whole period, times its hours), or Free's quota of the day (of volume data and of its cache, the level). null: whatever is used is included (traffic, of a plan that includes all that is sent).
- stoppedbooleanrequired
What the meter serves is stopped. On Paid: what the period includes of it is used up, and the account holds nothing to pay for more. On Free: its quota of the day is used up, whatever the account holds, until 00:00 UTC (
included_to).cpu,memory: the account's sandboxes are frozen and nothing new is made (frozen).requests: the requests for its sandboxes and apps are refused at the edges.egress: its sandboxes' traffic to the internet is stopped.logs: what its apps print is kept no longer.volume_data,volume_cache: never: what volumes keep past what a period includes is owed on Paid, and on Free a new volume or snapshot past the level is refused (403storage_quota_reached).
- memoryobjectrequired
One meter of the stretch the account is in (
included_fromtoincluded_to): a period of its subscription on Paid, or the day (UTC) on Free.- unitcpu_mslubmemory_gib_secondslubrequestslubvolume_data_gb_hourslubegress_byteslubvolume_cache_gb_hours+4 więcejrequired
What the quantities are in. Of a period of Paid: CPU-ms (milliseconds of a busy vCPU), GiB-seconds of memory, requests, GB-hours of volume data and of the NVMe cache, bytes sent, GB-hours of logs kept. Of Free's day, what its quotas count: the same of CPU, memory, requests and traffic; of volume data and of the cache the bytes kept at once (
volume_data_bytes,volume_cache_bytes: a level, as the last whole hour's books have it); of the logs the bytes printed in the day (log_bytes). - includednumber | nullrequired
What the stretch includes of the meter: Paid's quantity for the period (of volume data, of its cache and of the logs, the GB that may be kept for the whole period, times its hours), or Free's quota of the day (of volume data and of its cache, the level). null: whatever is used is included (traffic, of a plan that includes all that is sent).
- stoppedbooleanrequired
What the meter serves is stopped. On Paid: what the period includes of it is used up, and the account holds nothing to pay for more. On Free: its quota of the day is used up, whatever the account holds, until 00:00 UTC (
included_to).cpu,memory: the account's sandboxes are frozen and nothing new is made (frozen).requests: the requests for its sandboxes and apps are refused at the edges.egress: its sandboxes' traffic to the internet is stopped.logs: what its apps print is kept no longer.volume_data,volume_cache: never: what volumes keep past what a period includes is owed on Paid, and on Free a new volume or snapshot past the level is refused (403storage_quota_reached).
- requestsobjectrequired
One meter of the stretch the account is in (
included_fromtoincluded_to): a period of its subscription on Paid, or the day (UTC) on Free.- unitcpu_mslubmemory_gib_secondslubrequestslubvolume_data_gb_hourslubegress_byteslubvolume_cache_gb_hours+4 więcejrequired
What the quantities are in. Of a period of Paid: CPU-ms (milliseconds of a busy vCPU), GiB-seconds of memory, requests, GB-hours of volume data and of the NVMe cache, bytes sent, GB-hours of logs kept. Of Free's day, what its quotas count: the same of CPU, memory, requests and traffic; of volume data and of the cache the bytes kept at once (
volume_data_bytes,volume_cache_bytes: a level, as the last whole hour's books have it); of the logs the bytes printed in the day (log_bytes). - includednumber | nullrequired
What the stretch includes of the meter: Paid's quantity for the period (of volume data, of its cache and of the logs, the GB that may be kept for the whole period, times its hours), or Free's quota of the day (of volume data and of its cache, the level). null: whatever is used is included (traffic, of a plan that includes all that is sent).
- stoppedbooleanrequired
What the meter serves is stopped. On Paid: what the period includes of it is used up, and the account holds nothing to pay for more. On Free: its quota of the day is used up, whatever the account holds, until 00:00 UTC (
included_to).cpu,memory: the account's sandboxes are frozen and nothing new is made (frozen).requests: the requests for its sandboxes and apps are refused at the edges.egress: its sandboxes' traffic to the internet is stopped.logs: what its apps print is kept no longer.volume_data,volume_cache: never: what volumes keep past what a period includes is owed on Paid, and on Free a new volume or snapshot past the level is refused (403storage_quota_reached).
- volume_dataobjectrequired
What the account's volumes hold, its snapshots keep, its sleeping sandboxes keep of their own memory and disk, and the backups of its volumes keep: in GB-hours on Paid, in bytes kept at once on Free (a level, not a quota of the day).
- unitcpu_mslubmemory_gib_secondslubrequestslubvolume_data_gb_hourslubegress_byteslubvolume_cache_gb_hours+4 więcejrequired
What the quantities are in. Of a period of Paid: CPU-ms (milliseconds of a busy vCPU), GiB-seconds of memory, requests, GB-hours of volume data and of the NVMe cache, bytes sent, GB-hours of logs kept. Of Free's day, what its quotas count: the same of CPU, memory, requests and traffic; of volume data and of the cache the bytes kept at once (
volume_data_bytes,volume_cache_bytes: a level, as the last whole hour's books have it); of the logs the bytes printed in the day (log_bytes). - includednumber | nullrequired
What the stretch includes of the meter: Paid's quantity for the period (of volume data, of its cache and of the logs, the GB that may be kept for the whole period, times its hours), or Free's quota of the day (of volume data and of its cache, the level). null: whatever is used is included (traffic, of a plan that includes all that is sent).
- stoppedbooleanrequired
What the meter serves is stopped. On Paid: what the period includes of it is used up, and the account holds nothing to pay for more. On Free: its quota of the day is used up, whatever the account holds, until 00:00 UTC (
included_to).cpu,memory: the account's sandboxes are frozen and nothing new is made (frozen).requests: the requests for its sandboxes and apps are refused at the edges.egress: its sandboxes' traffic to the internet is stopped.logs: what its apps print is kept no longer.volume_data,volume_cache: never: what volumes keep past what a period includes is owed on Paid, and on Free a new volume or snapshot past the level is refused (403storage_quota_reached).
- egressobjectrequired
One meter of the stretch the account is in (
included_fromtoincluded_to): a period of its subscription on Paid, or the day (UTC) on Free.- unitcpu_mslubmemory_gib_secondslubrequestslubvolume_data_gb_hourslubegress_byteslubvolume_cache_gb_hours+4 więcejrequired
What the quantities are in. Of a period of Paid: CPU-ms (milliseconds of a busy vCPU), GiB-seconds of memory, requests, GB-hours of volume data and of the NVMe cache, bytes sent, GB-hours of logs kept. Of Free's day, what its quotas count: the same of CPU, memory, requests and traffic; of volume data and of the cache the bytes kept at once (
volume_data_bytes,volume_cache_bytes: a level, as the last whole hour's books have it); of the logs the bytes printed in the day (log_bytes). - includednumber | nullrequired
What the stretch includes of the meter: Paid's quantity for the period (of volume data, of its cache and of the logs, the GB that may be kept for the whole period, times its hours), or Free's quota of the day (of volume data and of its cache, the level). null: whatever is used is included (traffic, of a plan that includes all that is sent).
- stoppedbooleanrequired
What the meter serves is stopped. On Paid: what the period includes of it is used up, and the account holds nothing to pay for more. On Free: its quota of the day is used up, whatever the account holds, until 00:00 UTC (
included_to).cpu,memory: the account's sandboxes are frozen and nothing new is made (frozen).requests: the requests for its sandboxes and apps are refused at the edges.egress: its sandboxes' traffic to the internet is stopped.logs: what its apps print is kept no longer.volume_data,volume_cache: never: what volumes keep past what a period includes is owed on Paid, and on Free a new volume or snapshot past the level is refused (403storage_quota_reached).
- volume_cacheobjectrequired
What the account's volumes keep on their nodes' own NVMe, the less of the cache each is set to and the data it holds: in GB-hours on Paid, in bytes kept at once on Free (a level).
- unitcpu_mslubmemory_gib_secondslubrequestslubvolume_data_gb_hourslubegress_byteslubvolume_cache_gb_hours+4 więcejrequired
What the quantities are in. Of a period of Paid: CPU-ms (milliseconds of a busy vCPU), GiB-seconds of memory, requests, GB-hours of volume data and of the NVMe cache, bytes sent, GB-hours of logs kept. Of Free's day, what its quotas count: the same of CPU, memory, requests and traffic; of volume data and of the cache the bytes kept at once (
volume_data_bytes,volume_cache_bytes: a level, as the last whole hour's books have it); of the logs the bytes printed in the day (log_bytes). - includednumber | nullrequired
What the stretch includes of the meter: Paid's quantity for the period (of volume data, of its cache and of the logs, the GB that may be kept for the whole period, times its hours), or Free's quota of the day (of volume data and of its cache, the level). null: whatever is used is included (traffic, of a plan that includes all that is sent).
- stoppedbooleanrequired
What the meter serves is stopped. On Paid: what the period includes of it is used up, and the account holds nothing to pay for more. On Free: its quota of the day is used up, whatever the account holds, until 00:00 UTC (
included_to).cpu,memory: the account's sandboxes are frozen and nothing new is made (frozen).requests: the requests for its sandboxes and apps are refused at the edges.egress: its sandboxes' traffic to the internet is stopped.logs: what its apps print is kept no longer.volume_data,volume_cache: never: what volumes keep past what a period includes is owed on Paid, and on Free a new volume or snapshot past the level is refused (403storage_quota_reached).
- logsobjectrequired
What the account's apps printed that their nodes kept: on Paid for as long as it is kept, in GB-hours (each line's
text, counted as it was printed, for the hours it is kept); on Free what was printed in the day, in bytes.- unitcpu_mslubmemory_gib_secondslubrequestslubvolume_data_gb_hourslubegress_byteslubvolume_cache_gb_hours+4 więcejrequired
What the quantities are in. Of a period of Paid: CPU-ms (milliseconds of a busy vCPU), GiB-seconds of memory, requests, GB-hours of volume data and of the NVMe cache, bytes sent, GB-hours of logs kept. Of Free's day, what its quotas count: the same of CPU, memory, requests and traffic; of volume data and of the cache the bytes kept at once (
volume_data_bytes,volume_cache_bytes: a level, as the last whole hour's books have it); of the logs the bytes printed in the day (log_bytes). - includednumber | nullrequired
What the stretch includes of the meter: Paid's quantity for the period (of volume data, of its cache and of the logs, the GB that may be kept for the whole period, times its hours), or Free's quota of the day (of volume data and of its cache, the level). null: whatever is used is included (traffic, of a plan that includes all that is sent).
- stoppedbooleanrequired
What the meter serves is stopped. On Paid: what the period includes of it is used up, and the account holds nothing to pay for more. On Free: its quota of the day is used up, whatever the account holds, until 00:00 UTC (
included_to).cpu,memory: the account's sandboxes are frozen and nothing new is made (frozen).requests: the requests for its sandboxes and apps are refused at the edges.egress: its sandboxes' traffic to the internet is stopped.logs: what its apps print is kept no longer.volume_data,volume_cache: never: what volumes keep past what a period includes is owed on Paid, and on Free a new volume or snapshot past the level is refused (403storage_quota_reached).
- owednumberrequired
What the account owes: what its sleeping sandboxes, volumes, snapshots and backups kept past what its period of Paid includes while it held nothing. The first thing the next Credits pay. Nothing else is owed: what an account that holds nothing used of the other meters before the stop took hold is written off. An account on Free never owes.
- lotstablicaobjectrequired
The Credits it holds, lot by lot, the one that lapses first first: the order they are used in.
- kindcreditlubtopuplubmonth_grantlubperiod_grantrequired
credit: what the operator granted.topup: a top-up that was collected. (month_grant,period_grant: only in a store from before plans included quantities: Credits a calendar month, or a period of a subscription, gave. Nothing gives any now; those that were given pay as the others do and lapse when they would have.)
- frozenbooleanrequired
The account's sandboxes are frozen and nothing new is made in its projects, no sandbox, no volume and no snapshot (403
balance_used_up; of an account that owes, 402account_in_debtto every call but those that read what it owes and pay it, and those that list and delete what it stores). What it has is kept. What can be deleted is its to delete; while it owes, that is its volumes, its snapshots and its sandboxes, and nothing else. - frozen_reasonbalance_used_uplubquota_used_uplubaccount_in_debtlubnullrequired
balance_used_up: on Paid, the CPU time or the memory its period includes is used up, and the account holds nothing to pay for more;quota_used_up: on Free, the day's quota of CPU time or of memory is used up, until 00:00 UTC;account_in_debt: it owes (debt). null while it is not frozen. - max_volumesintegerrequired
How many volumes one project of the account may have (
POST /v1/volumesbeyond it is 403volume_limit_reached): the plan's, or the number an operator gave the account in its place. On Paid a soft limit, which holds back a script that runs away and is raised for an account on request. - max_volume_bytesintegerrequired
How large one of them may be (10 GiB on the free plan, 1 TiB on Paid, which no plan passes; an operator's number for the account, an enterprise customer's, up to 16 TiB, the largest a node makes): a create larger is 403
volume_limit_reached,paramsize_bytes; one that gives no size is given this, where a node's own (64 GiB) is more. - max_sandbox_secrets_bytesintegerrequired
How many bytes the values of the secrets one sandbox is given may come to together: an instance of an app, given them as environment variables and as files, a secret as often as it is given. A create, change or deploy of an app, and a new value of a secret, that would give its instances more (and more than they are given now) is 403
secret_limit_reached. A secret that a sandbox's egress rules send is not given to it: its value goes into the request on its way out. - capsobjectrequired
What the account may have at once, each cap's number and whose it is.
GET /v1/accounthas the same with what the account has of each now (used), which moves as sandboxes wake, sleep and are made, and is not in the bill (control/README.md). The plan's numbers (awake, their vCPUs, their memory, sleeping, an app's instances at the most and when it names none, made in a minute, made by a project in an hour, apps and versions made in an hour: Free 5, 10, 10 GiB, 20, 5 and 2, 10, 200, 10; Paid 500, 500, 1 000 GiB, 10 000, 500 and 50, 600, 10 000, 500), or an operator's for the account. A cap is a quota and no reservation: within it a node that is full refuses all the same (503no_capacity). It only stops new things: what is awake when it is reached, or when the account comes to a plan with smaller caps, goes on as it is. What is counted is what the nodes say of the account's sandboxes in all its projects, every few seconds (--usage-seconds), and what calls made since: a sandbox that its node woke by itself, for a request to one of its ports, and an app's instance that a node made or woke for a request, are counted from its node's next look. What was made in a minute or an hour is counted by the control plane in memory, from its start. Past a cap the account gets 403plan_cap_reached, whoseparamis the cap's name.- app_instancesobjectrequired
An app's instances in a region: the most its
scale.max_instancesandscale.min_instancesmay say (beyond it a create or a change of the app is refused), and what it has when it names nomax_instances. What its nodes are told it may have is that, and no more than the account has room for awake beside everything else of it that is awake, nor less than it has awake. - creates_per_hour_per_projectobjectrequired
Sandboxes one project of the account makes in an hour, sliding, counted as in a minute; each project has an hour of its own, and
usedis the most one of them made. At the limit the refusal isretryable, withRetry-After; where the minute is past too, the one that holds the call longer is the one named. - app_creates_per_hourobjectrequired
Apps and versions of apps the account makes in an hour, sliding: an app that is made (with or without an image), a deploy, and a change of an app that makes a version, one each; a call that makes nothing (refused, or a change of what holds at once) is not counted, and a rollback is not. An app the account has no room for is refused for that (
app_limit_reached) whatever the hour says. At the limit the refusal isretryable, withRetry-After.
- pricesobjectrequired
In US dollars, with at most six digits after the point: one price list for every product (a Browsers session, a database's instances and Drives are priced as any sandbox and volume are).
- volume_data_gb_month_usdnumberrequired
A GB-month of volume data: what volumes hold, what snapshots keep, what sleeping sandboxes keep of their own memory and disk, and what the backups of volumes keep in the object store (
--price-volume-data-gb-month). Nothing is priced of what is written to a volume or read of it. - volume_cache_gb_month_usdnumberrequired
A GB-month of a volume's NVMe cache: what its node keeps of it on its own disk, the less of the cache the volume is set to (all of it unless said) and the data it holds (
--price-volume-cache-gb-month). A volume fully cached so costs this andvolume_data_gb_month_usdtogether a GB-month of what it holds.
- subscriptionrequired
The account's subscription; null for an account that has none and has asked for none.
}Jeden z poniższych:
- Subscription
- statependinglubactivelubendinglubduelubunpaidrequired
pending: the account asked to subscribe, and the charge of its first period is being collected; it is on the free plan until then.active: in a period that is paid for, and the next is charged when it ends.ending: in a period that is paid for, at whose end the subscription ends (ends_at).due: the period that was paid for is over and the charge of the next is being collected.unpaid: that charge failed, and is made again (charge.retry_at). Whiledueorunpaidthe account is on its plan, held to what its last period was; what it uses is in no period, and is held against what the period that is due includes, whose it is once that is paid for; atends_atthe subscription has ended. - planpaidlubnullrequired
The plan the subscription goes on as:
paid. Whilepending: the plan that was asked for. - sincestring | nullrequired
When it began: its first period. null while
pending.format: date-time - dayinteger | nullrequired
The day of the month its periods begin on (in a month that has it); null while
pending. - chargedbooleanrequired
Whether its periods are charged to the account's card. false: the operator gave it, and nothing is charged when a period ends.
- fee_usdnumberrequired
What a period of it is charged: the fee of
plan; 0 for one that was given. - periodobject | nullrequired
The period the account is in; null while
pending. Whiledueorunpaid: the period that is not paid for yet.- fromstringrequiredformat: date-time
- tostringrequiredformat: date-time
- paidbooleanrequired
It is paid for, or was given.
- charge_idstring | nullrequired
The charge that paid for it, or the one that is being collected for it; null for a period that was given, and while no charge of it is with whoever collects.
- next_charge_atstring | nullrequired
When the charge of the next period is made: the end of the last period that is paid for. null when nothing is to be charged then: the subscription is to end, or was given; and while
pending,dueorunpaid, when the charge that counts is the one incharge.format: date-time - ends_atstring | nullrequired
ending: when the subscription ends, which is the end of the period that is paid for.due,unpaid: when it has ended unless the charge is collected before: the end of the grace period, seven days (as the control plane is started by default) after the end of the period that was paid for; the account is on the free plan from then. null otherwise.format: date-time - chargeobject | nullrequired
While
pending,dueorunpaid: the last charge that was made for the subscription, the one that is being collected or the one that failed. null otherwise.- idstringrequired
- planpaidlubnullrequired
The plan the charge pays a period of.
- stateto_collectlubcollectedlubfailedrequired
- failureobject | nullrequired
That it failed, as a charge's
failuresays it to the account:card_declinedorpayment_failed, never why; null unlessfailed.- codestringrequired
- messagestringrequired
- retry_atstring | nullrequired
Of a charge that failed: when the charge is made again; null when it is not.
format: date-time
- null
- debtrequired
What the account owes, since when, and when what it stores is deleted for it; null for an account that owes nothing.
GET /v1/accounthas the same, and the account'semail.}Jeden z poniższych:
- Debt
- objectstringrequired
- idstringrequired
- stateowinglubdeletinglubpaidlubdeletedrequired
owing: the account owes, and nothing of it can be used.deleting: its date is past, and what it stores is being deleted. An account is shown a debt of these two only.paid: it was paid, or what it owes came to less than a debt is.deleted: what the account stored was deleted, and what it owed was written off. - in_debt_sincestringrequired
When the account was found to owe as much as a debt is.
format: date-time - owed_usdnumberrequired
What it owes now: what its balance is below zero by. Of a debt that has ended, 0.
- data_deleted_atstring | nullrequired
When what the account stores is deleted if it still owes: the latest date a notice the sender accepted has said. Null while no notice of the debt has been accepted (nothing is deleted then), and while an operator holds the account. Of a debt that ended with the deletion, when that was.
format: date-time - notice_daysintegerrequired
How many days an account that owes is given from its first notice (
--debt-days). - on_holdbooleanrequired
An operator holds the account: nothing of it is deleted, and the count of its days stands still.
- charge_atstring | nullrequired
When what it owes is charged to the account's card next: 00:00 UTC on its first billing day after the debt began, or after it was last charged (a billing day is the day of the month the account's subscription began on, or, without one, the day its first top-up was collected; the last day of a month that has no such day). A time that has come is one to charge at the next look. Null: nothing is to be charged, as the account has no card on record (
Balance.card) or no billing day, an operator holds it, its deletion has begun, or it owes less than a debt is. What is charged is what it owes then, rounded up to the cent, and no more than the account's spend limit leaves in the calendar month (Balance.reload_left_usd): what that leaves owed is charged on the next billing day; where the limit leaves less than a debt is, nothing is charged that month, and the first look of the next month charges it (this time stays the one that has come until then).format: date-time - last_chargerequired
The last charge of what it owes to the account's card, and how it went; null before the first.
}Jeden z poniższych:
- DebtCharge
- null
- noticestablicaobjectrequired
The notices of this debt, the oldest first: the first one, and, once that is accepted, the reminders that are to come; and one of each charge of it that failed (
charge_failed).- idstringrequired
- objectstringrequired
- kindin_debtlubreminder_7lubreminder_14lubreminder_21lubreminder_27lubreminder_29+8 więcejrequired
in_debt: the first notice of a debt.reminder_<day>: on that day after it (the days are the control plane's,--debt-reminder-days).charge_failed: what it owes was charged to the account's card on its billing day, and the charge failed; one of each such charge.data_deleted: what the account stored has been deleted, and the debt is written off.storage_80,storage_100: before any debt, the storage the account's plan includes is used to four fifths, or used up, and it holds nothing.subscription_charge_failed: the fee of the period of its subscription that was due could not be charged; one of each such charge, the first and each one made again in the days of grace.reload_failed: an auto reload could not be charged; one of each.reload_no_card: auto reload is on and the balance below its line, and the account has no card on record to charge; once a calendar month while it is so.included_80,included_100: what its plan includes of CPU time, memory, requests or traffic is four fifths used, or all, and it holds nothing and auto reload will not top it up; once a meter, a mark and a stretch. - stateto_sendlubacceptedlubfailedlubcancelledrequired
to_send: not handed to the sender yet, or handed over and not answered.accepted: the sender took it to deliver.failed: the sender said that it could not; of a debt's notice another is made after a while.cancelled: it is sent no more (the debt was paid; a later reminder said what it would have). An account is not shown its cancelled ones. - due_atstringrequired
From when it is handed to the sender.
format: date-time - sent_atstring | nullrequired
When it was handed to the sender, of one the sender accepted; null otherwise. Of a debt's first notice: the moment the debt's days are counted from.
format: date-time - subjectstring | nullrequired
Its subject, once it has been handed over.
- null
- trustobjectrequired
What the account's trust level lets its top-ups come to (
trust_limit_exceeded,trust_limit.reached): the two amounts in force, each the level's, or one an operator gave the account in its place. Nothing of a level touches what the account holds.- levelintegerrequired
The account's trust level: 0 when it is new, 1 and 2 as its record of payments raises it (
--trust-level-1,--trust-level-2: so many days after its first collected payment, with no dispute and no fraud warning since), 3 as an operator gives it; an operator may set any.maximum: 3 · minimum: 0 - month_most_usdnumber | nullrequired
The most its top-ups and auto reloads may come to together in a calendar month (UTC), as is in force, counted as they are made: what was collected and what is with the collector or on a payment page, and not what failed or was taken back, nor what was charged on its billing day for what it owed. Null: no limit.
- rises_atstring | nullrequired
When the level rises by itself next, if no payment is disputed or warned of as a fraud before then: the first look of that day gives it. Null: it does not (an operator set it, the account never paid, a payment was disputed or warned of, or no level above it comes by itself).
format: date-time
400
invalid_json, unknown_field, unknown_parameter; invalid_field: spend_limit_usd is not a number of dollars, zero or more, or null; plan is not one of the two plans (free, paid); start_now_required: the account buys as a consumer in the EEA or the UK and did not ask for what it buys to be provided at once (start_now), and nothing was made.
- 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.- itemstablicaobjectrequired
The model's top-level elements:
name, each volume, network, config and secret, extensions.- treatmentdonelubadaptedlubignoredlubrefusedrequired
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.
- servicestablicaobjectrequired
The services the import takes, in the model's order.
- itemstablicaobjectrequired
- treatmentdonelubadaptedlubignoredlubrefusedrequired
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.}Jeden z poniższych:
- Runtime
- ulimitsmapaRuntimeLimitGivenrequired
- sysctlsmapastringrequired
- tmpfstablicaobjectrequired
- pathstringrequired
- size_bytesinteger | nullrequired
- modeintegerrequired
- dnsobjectrequired
- serverstablicastringrequired
- searchtablicastringrequired
- optionstablicastringrequired
- 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.- itemstablicaobjectrequired
The model's top-level elements:
name, each volume, network, config and secret, extensions.- treatmentdonelubadaptedlubignoredlubrefusedrequired
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.
- servicestablicaobjectrequired
The services the import takes, in the model's order.
- itemstablicaobjectrequired
- treatmentdonelubadaptedlubignoredlubrefusedrequired
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.}Jeden z poniższych:
- Runtime
- ulimitsmapaRuntimeLimitGivenrequired
- sysctlsmapastringrequired
- tmpfstablicaobjectrequired
- pathstringrequired
- size_bytesinteger | nullrequired
- modeintegerrequired
- dnsobjectrequired
- serverstablicastringrequired
- searchtablicastringrequired
- optionstablicastringrequired
- shm_size_bytesinteger | nullrequired
- null
403
key_scope: the key does not allow the scope the call takes (the message names it); needs_api_key: the operator's key, or the SSH gateway's; account_held: the account is held for its payments, and every call of its keys but GET /v1/account is refused so, before the scopes are looked at; trust_limit_exceeded: more than the account's trust level lets it have (GET /v1/billing, trust): a spend limit, or no limit, above what auto reload may take in a month at its level (param spend_limit_usd), an auto reload above it (reload_amount_usd), a top-up that would bring what its top-ups and auto reloads of the calendar month come to above what the level lets them (amount_usd). The message says the level, its two amounts, what of the month's is used, and what raises it; tax_region_business_only: the account is no business (it has no tax id that is verified, or being verified) and is in a place the platform sells only to businesses (its billing address, or, where it has none, the country of the address the call comes from: GET /v1/account, tax); the message names the place, and says how a business sets its tax id, which lets it pay at once (x-error-codes).
- 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.- itemstablicaobjectrequired
The model's top-level elements:
name, each volume, network, config and secret, extensions.- treatmentdonelubadaptedlubignoredlubrefusedrequired
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.
- servicestablicaobjectrequired
The services the import takes, in the model's order.
- itemstablicaobjectrequired
- treatmentdonelubadaptedlubignoredlubrefusedrequired
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.}Jeden z poniższych:
- Runtime
- ulimitsmapaRuntimeLimitGivenrequired
- sysctlsmapastringrequired
- tmpfstablicaobjectrequired
- pathstringrequired
- size_bytesinteger | nullrequired
- modeintegerrequired
- dnsobjectrequired
- serverstablicastringrequired
- searchtablicastringrequired
- optionstablicastringrequired
- shm_size_bytesinteger | nullrequired
- null
409
subscription_charge_pending: a charge of the account's subscription is being collected, and what it pays for cannot be changed, nor the subscription ended, until it has an answer. retryable. Of Paid, billing_address_required (param billing_address): the platform computes tax with Stripe Tax and Stripe collects, and Stripe Tax has no place for the account: it has no billing address, and the country of its card on record is not known (set its address with PATCH /v1/account, or pay on a payment page, POST /v1/billing/checkout, which asks for it). Nothing was made.
- 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.- itemstablicaobjectrequired
The model's top-level elements:
name, each volume, network, config and secret, extensions.- treatmentdonelubadaptedlubignoredlubrefusedrequired
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.
- servicestablicaobjectrequired
The services the import takes, in the model's order.
- itemstablicaobjectrequired
- treatmentdonelubadaptedlubignoredlubrefusedrequired
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.}Jeden z poniższych:
- Runtime
- ulimitsmapaRuntimeLimitGivenrequired
- sysctlsmapastringrequired
- tmpfstablicaobjectrequired
- pathstringrequired
- size_bytesinteger | nullrequired
- modeintegerrequired
- dnsobjectrequired
- serverstablicastringrequired
- searchtablicastringrequired
- optionstablicastringrequired
- shm_size_bytesinteger | nullrequired
- null