Changelog
Changes to the Fiberax API that can affect code already written against it, newest first. Each entry says what changed, which endpoints it touches, and what you need to do.
The version is part of the base path (/v1). How compatible and breaking changes are
handled is described under Versioning in the reference.
2026-11-18 - Changed: a network change while the previous one is still applying answers 409 server_busy
Endpoint: PATCH /v1/networks/{id}
What changed. While the task of a previous change to the same network is still waiting or running, a new
change is refused with 409 server_busy and a Retry-After header. Before, the second change
was accepted and its task could overwrite the first change with the values the network had when the first change
was accepted, so one of the two changes was silently lost.
What stays the same. The request and the 202 answer with its task when no change of this network is
in progress. Changes to different networks do not wait for each other.
What to do. Wait for the task of your previous change to finish before you send the next one, or repeat the
request after the time in Retry-After. To change several fields of one network, send them in one request.
Terraform. The provider waits for the task of each network change and repeats a request refused with
server_busy. No change needed.
2026-11-17 - Changed: a restart gives the operating system five minutes to shut down
Endpoint: POST /v1/servers/{id}/actions/reboot
What changed. A restart now gives the server's operating system 5 minutes to shut down instead of 60
seconds, so a slow guest is restarted instead of failing the task. The restart task can therefore stay
running for more than five minutes: up to 5 minutes for the operating system to shut down, then the
start. If the operating system has not shut down within the 5 minutes, the task fails as before, with
operation_failed and a message. If it shuts down later, within the next 10 minutes, the platform starts
the server again, unless another power action was requested for the server after the restart, or the server was
deleted or is busy with another operation.
What stays the same. The request, the 202 answer with its task, and the error code of a failed
restart. A clean shutdown (POST /v1/servers/{id}/actions/shutdown) still waits 60 seconds, and a reset
(POST /v1/servers/{id}/actions/reset) is unchanged.
What to do. If your client stops waiting for a restart task sooner than the shutdown time plus the server's start time, give it longer. After a failed restart, read the server before you start it: the platform may already have started it.
Terraform. The provider does not restart servers. No change needed.
2026-11-13 - Changed: a repeated OpenVPN device request replays the profile for ten minutes
Endpoints: POST /v1/servers/{id}/router/openvpn/devices,
POST /v1/servers/{id}/router/openvpn/devices/{device}/actions/reissue
What changed. A repeat with the same Idempotency-Key replays the stored answer, profile
included, for ten minutes after the first answer instead of 24 hours. The profile holds the private key of the
device, and we keep it no longer than a retry needs. After the ten minutes the key is free again: a repeated create
creates another device, and a repeated reissue lands on the old identifier and answers 404
vpn_device_not_found.
What stays the same. The answers themselves, the device limit and how repeats within the ten minutes behave. WireGuard devices are not affected: their answers carry no private key.
What to do. Nothing, if your client retries a dropped request within minutes, as clients normally do. If you
repeat a create later than that, read the devices first (GET /v1/servers/{id}/router/openvpn/devices) so
you do not create a second one.
Terraform. The provider retries a call within about two minutes. No change needed.
2026-11-02 - Release: reseller model, server console, transfers, billing data, webhooks and budgets
One release gathers what came to the API over the last two weeks: account keys and projects for resellers, moving and transferring servers and whole projects, the server console, SSH keys as text, the money of the account, webhooks and project budgets, and a set of fixes that make refusals more precise. Each section says what changed, which endpoints it touches and what to do; most need nothing from you. Links sent earlier to sections of this release still lead to them.
- Accounts and projects: account keys and projects, request budgets, moving a server to another project, a move that fails, a server on private networks, transferring a server to another account, transferring a whole project
- Servers: server console, SSH keys as text, sending a key again, messages of failed tasks, extra addresses and the backup rate, sizes of plan types
- Networks: limits on private networks, the limit per project, widening a subnet, attaching and detaching a router, private ranges only
- Backups: deleting a backup,
the backup policy without
enabled - Money: billing data, account and hourly costs, the currency of costs, costs before discounts, quantities in charges per server
- Webhooks and budgets: webhooks and project budgets, budgets only alert, e-mail alerts
- Object storage: access keys and buckets without reserved storage
- More precise answers, Terraform
Added: account keys and projects
Endpoints: GET, POST /v1/projects; GET, PATCH,
DELETE /v1/projects/{id}; GET /v1/projects/{id}/costs; GET,
POST /v1/projects/{id}/tokens, DELETE /v1/projects/{id}/tokens/{token_id}; the
Fiberax-Project header on every Virtual Data Center endpoint
What changed. A new kind of key, the account key, reaches every Virtual Data Center project of the
account. The account owner issues it on the API tokens page of the client area, up to 10 per account. With it you
order projects, rename them and change their labels, read their costs, issue and revoke their project keys, and
close a project once it is empty. On every other endpoint an account key names the project in the
Fiberax-Project header; without it the answer is 400 project_required. All account keys of
one account share one request budget for all its projects. An account holds up to 10 projects,
counting the ones ordered in the client area. New codes: project_required,
invalid_project_header, project_mismatch, account_key_required,
project_not_empty, project_busy, token_not_found, token_name_taken.
The Project object gains labels and created_at on the
/v1/projects endpoints, and its status is Pending for the first seconds after an
order: POST /v1/projects may answer with it, and while it lasts the project answers
409 service_provisioning. A 409 project_not_empty lists what is still in the project in
blockers. See the guide
Reseller: one project per customer.
What stays the same. Project keys work exactly as before: one project, no header needed, the same
budget. A project key may send Fiberax-Project only with its own project id; any other id is
refused with 400 project_mismatch. GET /v1/project answers in the same form as before.
What to do. Nothing, unless you want to manage several projects with one key. If your code compares
Project.status with a closed list of values, allow Pending before you use
GET /v1/projects.
Terraform. Provider 0.10.0 works with account keys: the provider argument
project_id names the project, and the new resources fiberax_project and
fiberax_project_token and the data source fiberax_projects manage projects and their keys.
Upgrade with version = "~> 0.10.0"; configurations with a project key need no change. See
Projects with an account key.
Changed: 120 reads a minute; partner account budgets
Endpoints: every endpoint (the request budget)
What changed. The read budget grows from 90 to 120 requests a minute; RateLimit-Limit on a read
says 120. One address may send about 120 requests at once instead of 100, so a whole minute of reads
fits in one burst. Partner accounts get 240 reads and 40 writes a minute for their account keys by default,
and up to 600 and 120 on request; the addresses of a partner's own servers can get a larger per-address
allowance.
What stays the same. 20 writes a minute, the calendar minute, the headers and the 429
with Retry-After; after a burst, one address still gets 4 requests a second and at most 20 in progress.
What to do. Nothing. If your code paces itself by a fixed 90, read RateLimit-Limit
instead.
Added: moving a server to another project
Endpoint: POST /v1/servers/{id}/actions/move
What changed. A server can move into another project of the same account, in the same datacenter,
without a restart: its number, disks, snapshots, backups, backup schedule, public address and saved password stay.
Only an account key can do this - name the project the server is in now in the Fiberax-Project
header and the receiving project in project_id. There is no code to confirm and nothing to accept.
The answer is 202 with the move and a task; poll GET /v1/tasks/{id} with the same
Fiberax-Project header. A failed task says why in error.message, and nothing has changed.
A router, a server with graphics cards, one attached to private networks or built from your own image cannot move:
the request answers the new code server_not_movable (409) with the reason in detail.
Usage up to the move stays with the old project. See section 11 of the guide
Reseller: one project per customer.
What stays the same. Every other endpoint, project keys included. A project key gets
403 account_key_required on this endpoint. Moving a server to another account is still the
transfer with a code (POST /v1/servers/{id}/actions/transfer).
What to do. Nothing, unless you want to move servers between your projects. Terraform: run
terraform state rm on the server in the old configuration and terraform import with the
same number in the new one.
Terraform. The provider has no resource for the move. No change needed.
Changed: a move task that fails because the server cannot move carries server_not_movable
Endpoints: POST /v1/servers/{id}/actions/move, GET /v1/tasks/{id}
What changed. A move task that fails for a reason of the server or of a project - the same reasons that
refuse the request with 409 server_not_movable, checked again while the task runs - now carries
error.code server_not_movable instead of operation_failed;
error.message says which, as before. Other failures of the task stay operation_failed.
What stays the same. The request and its answers, error.message and the tasks of other
operations.
What to do. Treat server_not_movable in a failed move task like the same code on the request:
change the server or the project, then move it again. Repeating the move with a new idempotency key while the
reason stays fails again.
Terraform. The provider has no resource for the move. No change needed.
Fixed: moving a server attached to private networks answers 409 server_not_movable at once
Endpoint: POST /v1/servers/{id}/actions/move
What changed. A server attached to a private network, or with a network card that has no public address
of its own, could be accepted with 202, and its task then failed. The request now reads the server's
network cards before anything is queued and answers 409 server_not_movable with the reason in
detail, as moving a server was documented.
What stays the same. The other refusals, the 202 of an accepted move and its task. When the
cards cannot be read at that moment, the move is accepted and its task checks them, as before.
What to do. Nothing, if you already handle 409 server_not_movable on this request: detach the
server from its private networks and remove any network card without a public address of its own, then move it
again.
Terraform. The provider has no resource for the move. No change needed.
Added: transferring a server to another account
Endpoints: POST /v1/servers/{id}/actions/transfer; GET /v1/transfers,
GET /v1/transfers/{id}; POST /v1/transfers/{id}/actions/confirm, resend,
cancel, accept, reject
What changed. A server can be offered to another account by its e-mail address, as on the Resource
Transfer page of the client area; a request made there is the same request and is visible through the API. The
request answers 201 in status unconfirmed and e-mails a 6-digit code to the account owner.
Nothing moves until the request is confirmed with that code and the recipient accepts it with a key of the project
that is to receive the server, in the same datacenter; the move then runs in the background within minutes. The
server keeps its number, disks, snapshots, backups, backup schedule and saved password. The code is the only
protection against a leaked key: no account password is asked, so never automate reading it. A code is valid for
30 minutes with 5 attempts, a request gets at most 5 codes, an account starts at most 10 requests in 24 hours, and
the recipient has 7 days to accept. Only keys of the account owner can do this, and reading requests needs a read
and write key, since they show the e-mail of the other side. A server that cannot go - a router, one with graphics
cards, a mounted ISO image, built from your own image, without a public address of its own, an account with an
overdue invoice or billed in a currency other than euros - is refused with server_not_transferable
(409) and the reason in detail. New codes: server_not_transferable,
transfer_not_found, transfer_open, transfer_limit_reached,
transfer_running, transfer_expired, transfer_closed,
invalid_transfer_code, transfer_code_expired, transfer_code_attempts_exhausted,
transfer_code_sends_exhausted, transfer_code_resend_pause, transfer_code_limit.
What stays the same. Moving a server between your own projects is the move above: no code and nothing to accept.
What to do. Nothing, unless you hand servers over to other accounts. After the move
GET /v1/servers/{id} in the old project answers 404. The server goes as it is: the
recipient sees its saved password, so change it first if you use it anywhere else.
Terraform. The provider has no resource for a transfer. If Terraform manages the server, run
terraform state rm on it before the move is done, or the next apply recreates it; the recipient runs
terraform import with the same number.
Added: transferring a whole project to another account
Endpoint: POST /v1/project/actions/transfer; the requests are read, confirmed and accepted
with the /v1/transfers endpoints of the section above
What changed. A project can be offered to another account with all its servers, networks, addresses,
backups and settings, the same way as one server: a code e-mailed to the account owner, confirmation, then the
recipient accepts with a key of any of their projects, and the project becomes a project of its own in their
account. Its move waits for quiet billing windows and can take up to an hour. Usage not yet invoiced is invoiced to
you at the move, unless usage_to_recipient hands it over to the recipient; such a request is accepted
in the client area only, where the recipient sees and agrees to the amount (transfer_accept_in_cabinet,
409, through the API). A project that cannot go - not active, being cancelled, a server operation running, VPN
devices on its router, a server type that cannot be transferred, an open request for one of its servers, unpaid
invoices, an account billed in a currency other than euros - is refused with project_not_transferable
(409) and the reason in detail. New codes: project_not_transferable,
transfer_accept_in_cabinet.
What stays the same. The numbers of the project and of everything in it. The passwords and SSH keys of its servers do not change, and the recipient sees the saved passwords: change them first if you use them anywhere else.
What to do. Nothing, unless you hand projects over. After the move every key of the project stops working
(401 invalid_token).
Terraform. Run terraform state rm on the project's resources before the move is done; the
recipient brings them under their configuration with terraform import and the same numbers.
Added: server console
Endpoints: POST /v1/servers/{id}/console
What changed. A key can open the VNC console of a running server: the call returns a one-time ticket that is
valid for 60 seconds and one WebSocket connection, a ready console page (viewer_url) and the WebSocket
for your own client or the proxy of your own portal (websocket_url). This needs console access on the key,
chosen when a read and write key is issued in the client area; existing keys have none. A team member also needs
the VNC Console permission. New codes: server_not_running and router_console_forbidden
(both 409); insufficient_scope on the console for keys without console access. See the guide
Server console.
What stays the same. Every other endpoint, and every key you already have.
What to do. Nothing, unless you want the console: issue a key with console access.
Added: SSH keys as text, outside the account pool
Endpoints: POST /v1/servers, POST /v1/servers/{id}/actions/add-ssh-keys,
POST /v1/servers/{id}/actions/rebuild, GET /v1/servers/{id}
What changed. A new field ssh_public_keys takes OpenSSH public keys as text, one per item,
and installs them on the server without adding them to the account pool (/v1/ssh-keys), which
every project of the account sees. It works next to ssh_keys (together at most 20 keys a server)
and is checked like public_key of the pool (invalid_ssh_key, with the item number);
DSA keys (ssh-dss) are not accepted as text, because the hypervisors run OpenSSH 10, which no longer
reads them. A key comment - as text or added to the pool through the API - must not contain control characters (a tab between the key and the comment counts too),
: or a trailing :, which break the server's cloud-init data (invalid_ssh_key).
Reinstalling now takes ssh_keys and ssh_public_keys: sending either replaces the
server's keys with exactly the keys sent; a reinstall without them installs the old set again. A server read
carries ssh_key_fingerprints: the SHA256 fingerprints of every key the platform installs on it
(null while the server is being created or reinstalled; the server list carries them or null,
so read the server itself for the reliable set). Keys sent as
text stay in the server's set when keys are added later, through the API or in the client area. New code: rebuild_ssh_keys_not_supported for keys sent with a reinstall of a
server that boots from installer media. See the guide Reseller.
What stays the same. ssh_keys and the pool, the response of add-ssh-keys
(the pool keys of the set; keys sent as text have no ID and are not listed), keys on Windows. In generated
clients ssh_keys of add-ssh-keys becomes optional, since ssh_public_keys
can replace it.
What to do. Nothing. If you keep your customers' keys in the pool only to pass them to servers,
send them in ssh_public_keys instead. A generated client with a strict Server model picks up
ssh_key_fingerprints after regeneration.
Terraform. Provider 0.11.0 takes ssh_public_keys on fiberax_server: keys
as text, installed at creation without going into the account pool. Changing the set never recreates the server.
Upgrade with version = "~> 0.11.0"; configurations without the field need no change.
Changed: sending again SSH keys the server already has answers 200
Endpoint: POST /v1/servers/{id}/actions/add-ssh-keys
What changed. When every key you send is a key given as text that the server already has, and the server has
no keys from the account pool, there is nothing to install: the answer is 200 with an empty
data list and task: null. Before, such a request was refused with 422.
What stays the same. A request with at least one new key, or for a server that has keys from the pool, answers
202 with a task.
What to do. Nothing, unless your code takes only 202 as success: read 200 with
task: null as "already installed".
Terraform. Not affected: the provider does not call this endpoint.
Changed: every failed task carries a message; a soft reboot or shutdown that times out says so
Endpoints: GET /v1/tasks/{id}, POST /v1/servers/{id}/actions/reboot,
POST /v1/servers/{id}/actions/shutdown
What changed. A failed task now always carries error.message, words for a person to read. Before,
most failed tasks had only error.code, and only the tasks of moving a router's public address and of moving a
server to another project named a cause. A failure without a known cause carries a general sentence: the operation did
not complete on the platform, read the resource and repeat the operation with a new idempotency key;
server_deleted says there is nothing to repeat.
A restart (reboot) or a clean shutdown (shutdown) asks the operating system of the server to
shut down and waits 60 seconds. If it does not shut down in that time - it is still booting, it ignores the request, or
it shuts down slowly - the task fails with operation_failed, and error.message in
GET /v1/tasks/{id} says so and what to do: read the server; if it is still running, repeat when it has
finished booting, or force it with POST /v1/servers/{id}/actions/reset (actions/power-off after a
shutdown); if a restart left it stopped, start it with actions/power-on. The platform does not force the
server after the timeout, but the request has reached the guest: one that was shutting down slowly stops later and
stays stopped.
What stays the same. The codes: a timed-out restart or shutdown is still operation_failed, and
error.code stays the field to branch on. The 202 answers of reboot and
shutdown, a task that succeeded (error is null) and the causes named by the router
and move tasks.
What to do. Show error.message to a person instead of an empty line; do not parse it, branch on
error.code. After a failed reboot or shutdown, read the server before you repeat.
Terraform. The provider does not restart or shut down servers. When a task it waits for fails, it reports
error.code and the task ID, not error.message. No change needed.
Clarified: extra addresses on a card, and the backup rate of a type
Endpoints: PATCH /v1/servers/{id}/network-interfaces/{interface},
POST /v1/servers/{id}/network-interfaces, GET /v1/server-types/{id}/pricing
What changed. Descriptions only, the behaviour is as it was. Inside the server the platform sets up one
address per card, its main one; an extra address on the card is routed and billed, but works once you add it in the
operating system yourself. Which address is main does not follow the order of ips. Adding or taking
off only an extra address does not restart the server; moving the card to another network or changing its main
address restarts a running server once. backup_gb in a type's pricing is a billing multiplier, not a
price of backups.
What to do. Nothing, unless you expected an extra address to come up in the server by itself.
Clarified: sizes of plan types, and a plan change on a running server
Endpoint: PATCH /v1/servers/{id}
What changed. The guide Server lifecycle now says what the API already
does. On a type sized by plans, the size fields are refused with resources_managed_by_plan (422): the
plan sets cores, memory and disks, so the size changes through plan_id, and a data disk cannot be added
or grown either. On a slider type, plan_id is refused with plan_not_supported (422). A plan
change goes up only and needs a stopped server: on a running one a real upgrade answers
server_not_stopped (409). Refusals on the substance come first, at any power state -
plan_not_found (404), plan_downgrade_not_allowed (422) - so you never stop a server for a
request that cannot pass; asking for the plan the server already has answers 200 with no task.
What to do. On server_not_stopped, power the server off, wait for the task, and repeat the same
request with the same Idempotency-Key.
Changed: limits on private networks
Endpoints: POST /v1/networks; the tasks of POST /v1/networks and DELETE /v1/networks/{id}
What changed. An account can hold up to 18279 private networks across all its projects, the default
network of each project among them; before, the limit was 27. Running out of them answers
409 quota_exceeded, and its detail says that the account limit, not the project one, was
reached. When the platform has no room for a new private network right now, the request is refused with
409 quota_exceeded as well; its detail says so and that support can help. A task that
creates or deletes a network can take longer than before: it now ends only when the network is in place.
What stays the same. A project still holds up to 10 private networks. Existing networks keep their names.
What to do. Nothing, unless your code reads the detail of quota_exceeded, or
waits for a network task with a short timeout.
Changed: the private network limit may differ per project
Endpoints: POST /v1/networks
What changed. A project holds up to 10 private networks, the default network included, unless its limit
is different: support can set another limit for a project on request. The detail of
409 quota_exceeded names the limit of your project, for example "This project holds 27 of 27 allowed
private networks (the default network counts)"; a project whose limit is 0 gets "This project cannot create
private networks: its limit is 0".
What stays the same. The default limit is 10. The account limit of 18279 private networks across all projects and the platform limit stay as they were.
What to do. Nothing, unless your code takes 10 for granted: read the limit from the detail,
or ask support to raise it for a project.
Changed: the subnet of a network with servers can be widened
Endpoint: PATCH /v1/networks/{id} with cidr
What changed. While servers are attached to the network, a new subnet that contains the current one is
now accepted, for example 10.8.8.0/22 for a network on 10.8.8.0/24. Before, any change of
the subnet was refused with network_in_use (409) while servers were attached. Only the range recorded for
the network changes: the servers are not restarted and their settings are not rewritten. In a network without a
router the platform hands out no addresses, so your servers learn the new mask from your own DHCP server when they
renew their lease, or, where the address was set by hand, when you change it in the operating system.
What stays the same. With servers attached, a subnet that does not contain the current one, narrower or
moved elsewhere, is refused with network_in_use (409); detail now names the current range.
Servers of every project of yours count, including ones still being created or reinstalled. While a router is linked
to the network, any change of its subnet, widening included, is refused with network_has_router (409). A
network with neither servers nor a router takes any valid subnet. The response is 202 with a task, and
data shows the network as it was when the request was accepted; when the change is made inside the
request, the response is 200 with task null and the changed network.
What to do. Nothing, unless you want to widen a network that has servers. Widening cannot be undone while servers are attached: a narrower subnet, the previous one included, is refused until no server of any of your projects is attached to the network. Once the task has succeeded, set the new mask and address range on your DHCP server or router inside the network and on servers whose addresses are set by hand.
Terraform. Current provider versions still warn during plan that the subnet can only be changed on a free
network; for widening the warning is out of date, and apply changes the subnet in place. Narrowing or moving the
subnet of a network with servers still fails on apply with network_in_use, and a network with a router
is still stopped during plan.
Changed: attaching and detaching a router answer server_busy while the platform holds the router
Endpoints: PUT /v1/networks/{id}/router, DELETE /v1/networks/{id}/router
What changed. While the platform holds the router's configuration - its backup is being taken, or another
platform operation is changing it - attaching the router to a network now answers server_busy (409)
with Retry-After, and the detail names the reason; the network is left without the router,
and repeating the attach after the pause attaches it. Before, it answered internal_error (500).
Detaching in the same situation now also answers server_busy (409) with Retry-After.
Before, it answered 200 and the network read as detached, but the router kept its network interface on
that network, and deleting the network afterwards was refused with network_in_use, naming the router as
a server that still has a network interface in it. A refused detach can come after the router has already stopped
serving the network (handing out addresses, internet access, the OpenVPN route); reading the network still shows the
router until a repeated detach finishes.
What stays the same. Another change to the same router, through the API or the client area, answers
server_busy (409) with Retry-After as before, and nothing is changed. All other refusals of
both operations are unchanged.
What to do. On server_busy, wait for Retry-After and repeat the same request; a
repeated detach finishes the work. Do not read server_busy from a detach as "nothing changed": read the
network and repeat until its router is gone.
Terraform. The provider does not attach or detach routers; no change needed.
Changed: private networks take private ranges only
Endpoints: POST /v1/networks, PATCH /v1/networks/{id}
What changed. The subnet of a new network, and a new subnet of an existing one, must lie wholly inside a
private range (RFC 1918): 10.0.0.0/8, 172.16.0.0/12 or 192.168.0.0/16. Anything
else - a public range such as 8.8.8.0/24, or a subnet wider than a private range such as
192.168.0.0/15 - is refused with 422 invalid_cidr, and the detail names the three ranges together with
172.16.0.0/16 and 172.17.0.0/16, which stay reserved for the VPN of routers;
before, it was accepted. A public range inside a project hides the real addresses of that range from its servers, from
every network behind the same router and from its VPN devices: with 8.8.8.0/24, the public DNS resolver
8.8.8.8 is no longer reachable. The console applies the same rule.
What stays the same. A network whose stored subnet lies outside these ranges keeps it: renaming it, or sending
its current subnet unchanged, is not refused for its range. A subnet that overlaps 172.16.0.0/16 or
172.17.0.0/16 is still refused as reserved for the VPN of routers, with the same detail as before.
What to do. Nothing, if your networks use private ranges. If your code creates networks on other ranges, choose a private one.
Terraform. A fiberax_network with a subnet outside the private ranges now fails at apply with
422 invalid_cidr; networks already in state are not affected.
Changed: a backup deletion succeeds only once the archive is gone
Endpoint: DELETE /v1/servers/{id}/backups/{backup}; also GET /v1/servers/{id}/backups,
GET /v1/servers/{id}/events
What changed. The deletion task now waits until the storage has finished removing the archive. It
ends succeeded only then. If the storage did not remove the archive or could not be reached, the
task ends failed with error.code operation_failed, and the backup returns to
the status it had before the deletion: one that was available reads available again and
can be restored or deleted. Before, the task could end succeeded while the archive stayed on the
storage, and the backup came back in the list later under the same id. Because of the wait, a deletion now
takes a few seconds rather than about one, and longer for a backup still being taken: the task first waits
for it to stop. A scheduled backup that did not complete may now stay in the list with
status failed instead of disappearing, while the storage shows neither that its archive is gone
nor that it is complete. While the server's backup policy is enabled, it is checked again about every hour:
it disappears once the storage confirms the archive is gone, and reads available if the archive
turns out complete; otherwise it stays failed. While a deletion runs, size_bytes is
null in the read and in the list alike, as while a backup is being taken. A deletion that finds the
archive already gone - removed earlier, or a backup deleted while it was being taken - is recorded in the server
events as backup_deleted, as any other deletion.
What stays the same. The answers to the call: 202 with a task, 200 with
task: null while a deletion of the same backup is under way, 404 backup_not_found once it is
gone, 409 server_busy while the server is being restored. The response body and the five backup
statuses.
What to do. Wait for the task. After failed, read the backup: if it is still listed,
repeat the deletion later; if the read answers 404, it is gone. A backup that was still being taken
is stopped by the deletion: if it still reads creating after a failed deletion, it will not finish -
delete it again. A repeat sent a couple of seconds after the first call now more often gets 200 with
task: null than 404. Treat a backup with status failed as one without a usable
archive and delete it; a scheduled one may also be removed by the hourly check while the backup policy is
enabled.
Terraform. The provider does not manage backups; no change needed.
Changed: the backup policy of a server can be written without enabled
Endpoint: PUT /v1/servers/{id}/backup-policy
What changed. enabled is no longer required. Leave it out to change only the schedule:
{"times": ["03:00", "15:00"]} or {"days": ["mon", "thu"]} keeps backups on or off as they are, as
the description of the operation always said - fields you leave out keep their current value. On a server that has no
schedule yet, such a body sets one up switched off: it does not start backups or their billing. While such a server is still being created, a body without enabled answers 409 server_busy with Retry-After: repeat it when the server is ready. A body with no fields at
all is refused with 422 invalid_request ("at least one field required"); before, it was refused because
enabled was missing.
What stays the same. A body with enabled works exactly as before, with or without schedule fields.
While the project is in debt or suspended, only switching off is accepted: send enabled: false - a body
without enabled is refused with 402, like switching on.
What to do. Nothing. If you generate a client from the specification, enabled of this request body
becomes optional on the next generation (in Go, a pointer).
Terraform. Not affected: fiberax_server_backup_policy always sends enabled.
Added: billing data of the account
Endpoints: GET /v1/billing/* (balance, invoices with their lines and PDF, credit receipts and their PDF,
payments, credit history, debt), GET /v1/project/costs/forecast,
GET /v1/projects/{id}/costs/forecast, GET /v1/account/forecast,
GET /v1/server-types/{id}/quote
What changed. An account key can read the money of the account: the balance, what has been charged and not yet
invoiced, unpaid and overdue amounts and when services would be suspended for them, invoices with their lines and PDF,
credit receipts, payments and the history of the credit balance. This needs billing access on the key, chosen when the
key is issued in the client area (billing: none or read); existing keys have none.
A forecast of the month for a project and for the account is marked estimated. A quote prices a server
configuration before you create it. New codes: insufficient_scope on billing paths without billing access,
document_not_final for the PDF of an unpaid receipt. See the guide
Billing data.
What stays the same. Project keys: they read the costs of their own project as before and none of the money of the account. Nothing here pays, creates or changes an invoice.
What to do. Nothing, unless you want billing data: issue an account key with billing access.
Added: costs of the whole account, hourly costs per server, CSV export
Endpoints: GET /v1/account/costs, GET /v1/account/costs/csv,
GET /v1/project/costs/servers, GET /v1/project/costs/servers/csv,
GET /v1/projects/{id}/costs/servers, GET /v1/projects/{id}/costs/servers/csv
What changed. An account key reads the costs of all its projects in one call, each project as
GET /v1/projects/{id}/costs gives it and their sum, optionally grouped by project label
(group_by=label, label_prefix) - for a reseller, the cost per customer. The per-server
costs accept granularity=hourly for the last 35 days, up to the last recorded hour; an older window is
refused with the new code window_out_of_range. An account key reads the per-server costs of any of its
projects by path. Every costs answer of these can be downloaded as CSV by adding /csv to the path. See
the guide Billing data.
What stays the same. All existing answers, fields and codes. Account costs are usage and need no billing access; project keys read the costs of their own project as before.
What to do. Nothing. If your code checks granularity of the per-server costs against
none and daily only, accept hourly too.
Changed: cost amounts are in the currency of the account
Endpoints: GET /v1/project/costs, GET /v1/project/costs/servers and their
/v1/projects/{id}/..., /v1/account/... and /csv forms
What changed. Amounts are given in the currency of the account, and currency is its ISO code,
EUR. A charge recorded in another currency is converted at the current exchange rate; before, it was
added to the total as it was recorded. When the currency of the account cannot be determined, or a charge is
recorded in a currency with no usable exchange rate, the answer is costs_unavailable (503).
What stays the same. The fields and the form of the answers. For an account whose charges are all in euros, the figures do not change.
What to do. Nothing. Read currency rather than assume it.
Clarified: costs are shown before discounts
Endpoints: GET /v1/project/costs, GET /v1/project/costs/servers,
GET /v1/account/costs and the forecasts
What changed. Descriptions only, the calculation is as it was. Costs show the charges at full price:
discounts of the account, coupons included, are not taken off. The invoice takes them off, so the invoice of a
discounted service is smaller than period_total by that discount; period_total is the
figure the invoice is built from before discounts. What is still to be invoiced after discounts is
accrued in GET /v1/billing/balance (an account key with billing access).
What to do. Nothing, unless your account has a discount and your code compares costs with invoices.
Added: quantities in charges per server
Endpoints: GET /v1/project/costs/servers, GET /v1/projects/{id}/costs/servers and their /csv exports
What changed. Every item of a server - in the server's items, in each daily or hourly bucket and in
unattached - now carries quantity and unit, in the units of GET /v1/project/costs:
Core-Hours for cores and license, GB-Hours for memory and storage, IP-Hours for addresses,
GPU-Hours for a GPU, and Hours for a plan - the hours the server was billed on it. The quantity is recorded
together with the charge, so a later price change does not move it: you can bill your customers from it at your own prices.
Backups carry quantity and unit null, as in GET /v1/project/costs. A server with cards of two GPU
models now has a line per model; before, both came as one line under the name of one of them. The CSV exports gain two columns
at the end of each row, quantity and unit, empty where the JSON answer has null.
What stays the same. sku, name and amount of every line, all totals, and the lines of a
server with one GPU model. Quantities start with this change and are not filled in backwards: an item whose window or bucket
reaches into time recorded before it - the daily bucket of this day and the hourly bucket of the hour of the change included -
comes with quantity and unit null, never with a partial count. On a server with cards of two GPU models
this applies to every GPU line of such a window or bucket.
What to do. Nothing, unless you want the quantities. A CSV reader that checks the exact header, or the number of columns, needs to accept the two new ones.
Terraform. Not affected: the provider does not read charges.
Added: webhooks and project budgets
Endpoints: /v1/webhooks and the paths under it, GET /v1/events, GET /v1/project/budget,
GET, PUT and DELETE /v1/projects/{id}/budget
What changed. An account key with billing access can subscribe HTTPS addresses of its own to events of the
account; changes need read and write access. Events: invoice.created, invoice.paid,
invoice.overdue, balance.low (the balance dropped below a threshold set on the subscription),
project.created, project.suspended, project.resumed, project.deleted,
budget.threshold_reached, budget.exceeded. Each event arrives as a POST with the event
as JSON, signed per Standard Webhooks (webhook-id, webhook-timestamp,
webhook-signature) with a secret shown once, when the subscription is created;
actions/rotate-secret issues a new one, and the previous one keeps signing for 24 hours. An answer other than
2xx within 5 seconds is retried after 1 minute, 5 minutes, 30 minutes, 2, 5, 10 and 10 hours, about 27 hours
in all, then given up; a subscription whose deliveries fail for 72 hours is disabled, and the account owner gets an
e-mail. The URL must be https:// on port 443 with a host name, and every address the name resolves to must
be public: private, loopback, link-local and other reserved networks, and the host names and networks of our platform,
are refused with 422 invalid_webhook_url naming the reason. The check repeats before every delivery, and
redirects are not followed. An account holds up to 10 subscriptions, one per URL. GET /v1/events lists the
events of the last 30 days, delivered or not; actions/test sends a webhook.test event.
A project can have a budget for its billing period: an amount in the currency of the account, up to five thresholds
in percent (by default 50, 80 and 100). About hourly, after usage is recorded, the platform
compares what the project charged in the period with the budget. Each threshold reached sends
budget.threshold_reached and the budget reached sends budget.exceeded, once per period for that
budget: another amount, or a new currency of the account, is a new budget, and its events come again within the same
period; writing the same amount again repeats nothing. period_start in these events is UTC with
Z, the same value as in GET /v1/project/budget. A budget only informs: it does not limit or
stop anything in the project. The budget is
written with an account key with billing access and read by any key of the project; it belongs to the account that
owns the project, and a project transferred to another account loses it.
Other new codes: webhook_not_found, delivery_not_found, budget_not_found (404),
webhook_exists, webhook_disabled (409), invalid_webhook_url (422),
webhooks_unavailable, budgets_unavailable (503). Step by step: the guide
Webhooks and budgets.
What stays the same. Nothing is sent to an account that did not subscribe. No request is refused because of a budget: servers keep running and charging, and usage is recorded an hour or two late.
What to do. Nothing, unless you want notifications or budgets. If you subscribe, verify the signature of every
delivery and deduplicate by webhook-id: deliveries can repeat and arrive out of order. To hold spending when a budget is
reached, act on budget.exceeded in your own automation.
Terraform. The provider has no resources for webhooks or budgets. No change needed.
Changed: project budgets only alert - enforce and budget_exceeded removed
Endpoints: PUT /v1/projects/{id}/budget, GET /v1/projects/{id}/budget, GET /v1/project/budget,
the budget.exceeded event; every request that creates or grows resources in a project with a budget
What changed. A budget now only informs and never limits a project. The field enforce is removed: it is
no longer in the budget read or in budget.exceeded, and a PUT that sends it is refused with
422 invalid_request naming it an unknown field. The code budget_exceeded (402) is removed: no request
is refused because a budget is reached - creating a server, more cores or memory, disks, plans, addresses, network cards,
backups and snapshots, images, networks and moves into the project work as without a budget, in the API and in the
console. Budgets already set keep their amount, thresholds and events; the ones that had enforce stop
nothing from now on.
What stays the same. Amount, thresholds, the evaluation about hourly after usage is recorded, the events
budget.threshold_reached and budget.exceeded and their deliveries. A project without a budget gets
no budget events.
What to do. Stop sending enforce in PUT /v1/projects/{id}/budget, and stop reading it from the
budget and from budget.exceeded; a client that handled 402 budget_exceeded can drop that branch. To
hold spending when a budget is reached, act on budget.exceeded in your own automation. The budget is written
whole: a field you leave out takes its default (thresholds 50, 80, 100), so send every field you want to keep on
each PUT.
Terraform. Not affected: the provider has no budget resource, and no request of it is refused by a budget any more.
Added: e-mail alerts for project budgets; notify_email and currency_changed in the budget
Endpoints: PUT /v1/projects/{id}/budget, GET /v1/projects/{id}/budget, GET /v1/project/budget
What changed. A budget now also e-mails the account owner when a threshold or the budget is reached, once per
billing period for that amount, in the language of the account - the same moments that send
budget.threshold_reached and budget.exceeded to webhooks. Thresholds reached together (for example
100% and the budget itself, or every threshold of a budget set below what is already charged) send one e-mail, for the
highest. E-mails go only while the project is active. The new field notify_email (boolean) switches the
e-mails of a budget off and on. It is in the request body of PUT and in every budget read. Leave it out and it
is true; budgets written before the field appeared have it true too.
The new read-only field currency_changed (boolean) is in every budget read. It is true when the
account now uses another currency than the budget was written in: such a budget is not evaluated - no events and no
e-mails - until you write it again with PUT.
What stays the same. Webhook events and their deliveries do not change and do not depend on the e-mails. A budget only informs: it does not limit or stop anything. A project without a budget gets neither events nor e-mails.
What to do. Nothing if the e-mails are welcome. To keep a budget silent, send "notify_email": false.
The budget is written whole: a field you leave out takes its default (thresholds 50, 80, 100;
notify_email true), so send every field you want to keep on each PUT. If a budget reads
currency_changed: true, write it again in the new currency. A strict client generated from the specification
gets the new response fields on the next generation.
Terraform. Not affected: the provider has no budget resource.
Changed: S3 access keys and buckets of a project without reserved storage
Endpoints: GET /v1/object-storage/access-keys, GET /v1/object-storage/access-keys/{id},
POST /v1/object-storage/access-keys/{id}/actions/reveal-secret,
POST /v1/object-storage/buckets
What changed. While an object storage project has no storage reserved, its access keys are read and their
secret is shown only when the owner has a payment card or credit on the account and no overdue invoice; otherwise
the answer is card_verification_required or client_has_debt (402), as the client area
shows such a project without its keys. A bucket lives in the reserved storage, so a project with none reserved is
refused with the new code storage_not_reserved (409), whatever the means to pay; an owner with an
overdue invoice gets client_has_debt (402) first. max_buckets of the object storage is
0 until storage is reserved, never negative.
What stays the same. A project with reserved storage. Creating an access key or a service account while none is reserved needs a means to pay, as before.
What to do. Reserve storage with PUT /v1/object-storage first, and create buckets only after
it has succeeded.
Terraform. Create fiberax_object_storage_reservation before the buckets: give each
fiberax_object_storage_bucket a depends_on on it.
Changed: more precise answers
Endpoints: as named in each item
What changed. Several answers that read as a final verdict or as an error of ours now say what happened:
- When we cannot read right now whether the API is on, every endpoint answers
503 server_unavailablewithRetry-After, notplatform_disabled.POST /v1/isosanswers503 server_unavailable, not402 card_verification_required, when the owner or the means to pay cannot be read. GET /v1/servers/{id}/private-ipsanswers503 server_unavailablewithRetry-After, not500, when the link to the host breaks during the read.- A size change with
PATCH /v1/servers/{id}that was made is no longer reported as500 internal_errorwhen only a status read on the way failed. Idempotency-Keytimes are kept in UTC. During the autumn clock change an abandoned key no longer answers409 idempotency_in_progressfor up to an hour instead of 120 seconds; a stored result is kept the full 24 hours, and the stored answer ofreveal-secretis no longer dropped right after it is saved, so a repeat within 10 minutes gets it.GET /v1/servers/{id}/events: one change of the server firewall is onefirewall_changedevent, however many rules it touched; a change the API refused (422, or 409 after a rollback) readsfailed, notsucceeded; a change that was made but could not be read back (503 firewall_unavailable) readssucceeded, notfailed; paging withenddoes not repeat a change.startandendof costs, costs by server, metrics and events: a bare+in the offset arrives as a space, and the refusal now says to send it as%2B. A space in its place is still refused.
What to do. Nothing. Treat 503 server_unavailable as temporary and retry after
Retry-After. If your code counted firewall_changed events per rule, count them per change.
Terraform
Provider versions of this release, in order, all on the mirror:
0.10.0- account keys and projects: the provider argumentproject_id, the resourcesfiberax_projectandfiberax_project_token, the data sourcefiberax_projects(account keys and projects).0.11.0-ssh_public_keysonfiberax_server(SSH keys as text).
Upgrade with version = "~> 0.11.0"; a configuration written for an earlier version needs no
change. The provider has no resources for moving or transferring servers and projects; see those sections for
terraform state rm and terraform import.
2026-10-20 - Changed: the default cost window starts where the billing period does
Endpoints: GET /v1/project/costs, GET /v1/project/costs/servers without
start and end
What changed. Without start and end, period_start is now always the moment
the previous billing period of the project closed - with an invoice or with nothing to bill - or the order of the
project if none has closed yet. Before, for a short while after an invoice, and all the time for a project with no
usage since its period closed, it was the start of the calendar month, and the window could include hours an
invoice had already billed. In this window, an hour before period_start comes as a bucket only when it
holds a charge of this period, recorded late - not as an empty bucket.
What stays the same. Windows given with start and end. For a project with usage
since its period closed, period_start and the amounts.
What to do. Nothing, unless you relied on period_start being the start of the calendar month.
2026-10-20 - Added: costs of object storage
Endpoints: GET /v1/project/costs with an object storage token
What changed. GET /v1/project/costs now answers for an object storage service in the same form
as for a VDC project. The service has one line, object_storage: the storage reserved for it, in
TB-Hours (1 TB = 2^40 bytes, as in reserved_tb), billed hour by hour whatever is actually stored;
server_type_id is null. Before, the answer was 404 not_found.
What stays the same. GET /v1/project/costs/servers is VDC only: an object storage token gets
404 not_found. Like the other object storage endpoints, costs share the object storage pool: while it is
full, the answer is 429 rate_limited with Retry-After.
What to do. Nothing, unless you want the costs of your object storage.
2026-10-20 - Changed: the title of card_verification_required also names account credit
Endpoints: POST /v1/servers, POST /v1/ips, POST /v1/isos,
PATCH /v1/servers/{id}/network-interfaces/{interface}; PUT /v1/object-storage, and
POST /v1/object-storage/buckets, POST /v1/object-storage/access-keys,
POST /v1/object-storage/service-accounts while no storage is reserved
What changed. The title of this refusal now reads "A payment card or account credit is needed
before paid resources can be created". It used to read "A payment card must be linked before paid resources can be
created", though a positive credit balance on the account is enough as well: the refusal comes when the platform
finds neither a verified payment card nor credit on the account of the project's owner.
What stays the same. The code card_verification_required, the status 402 and
type, and when this refusal comes.
What to do. Nothing, if your code branches on code. If it compares title with the
old wording, branch on code instead: title is for people and may change.
Terraform. The provider branches on the code; only the error message it prints quotes the new title. No change needed.
2026-10-16 - Added: object storage
Endpoints: GET, PUT /v1/object-storage; GET /v1/object-storage/usage;
GET, POST /v1/object-storage/buckets, GET, DELETE /v1/object-storage/buckets/{name};
GET, POST /v1/object-storage/access-keys, GET, DELETE /v1/object-storage/access-keys/{access_key_id},
POST /v1/object-storage/access-keys/{access_key_id}/actions/reveal-secret;
GET, POST /v1/object-storage/service-accounts, GET, DELETE /v1/object-storage/service-accounts/{name};
also GET, PATCH /v1/project with an object storage token
What changed. Object storage services are now managed through the API: the S3 endpoint and region, the
reserved volume (PUT /v1/object-storage with reserved_tb), usage, buckets, S3 access keys
and service accounts, and the name of the service. Tokens for an object storage service are issued on
the same API tokens page of the client area as for a
VDC project. Reserving volume needs a means to pay on the account - a verified card or credit
(402 card_verification_required) - and no overdue invoice (402 client_has_debt). On a
service with no reserved volume yet, creating a bucket, an access key or a service account needs the same. Reading,
renaming and deleting never do.
What stays the same. Everything about VDC projects, and the rules shared by all operations: the response
envelope, error codes, rate limits and idempotency keys. A token belongs to one project of one product: a VDC token
answers 404 not_found on the object storage paths and an object storage token on the VDC paths, with a
detail that names the product.
What to do. Nothing, if you do not use object storage. To start, issue a token for your object storage
service and read GET /v1/object-storage. If your client is generated from the OpenAPI description,
regenerate it to get the new operations and models.
Terraform. Provider 0.9.0 manages object storage - resources fiberax_object_storage_bucket,
fiberax_object_storage_access_key, fiberax_object_storage_service_account and
fiberax_object_storage_reservation, data source fiberax_object_storage. Use
version = "~> 0.9.0"; an object storage project has its own token, so give it a second provider
configuration with an alias and an explicit token.
2026-10-16 - Changed: moving a router's public address finishes in its task; addresses being attached by a task are held
Endpoints: PUT /v1/servers/{id}/router/wan-ip; also POST /v1/servers with public_ipv4,
PATCH /v1/servers/{id}/network-interfaces/{interface} with ips or public_ipv4, DELETE /v1/ips/{id}
What changed. Moving a router's public address checks the router and answers 202 with a task
within about a second; the move itself - the address and the port forwards on the router, then the platform's
records - runs in that task. The move is complete only when the task has succeeded; while it runs, the router may
be on either address. Two outcomes that used to come as the answer to the call now come as a failed task with
error.code: router_unreachable when the router did not answer on the new address and was
restarted on its previous one (before: 503 with Retry-After: 90), and
router_apply_failed when the router refused the new address (before: 503). A failed task
also says router_unreachable when the router stopped answering between the call and the start of the
task (nothing was changed then), and operation_failed when the platform's records could not be brought
in line. The task's error of this call may now carry message: what happened to the router,
in words.
New answers of the call: 409 server_busy with Retry-After while a move of the same router
is waiting or running - for any change to that router, a repeat of the same move included - and when the router is
busy with another operation of the platform (a backup, a reinstall, a move); 503 server_unavailable with
Retry-After when the task queue does not accept the move (nothing was changed - repeat it).
An address that a running task is attaching to a machine - the router's new address during a move, or an address
a network interface change is putting on a server - is held until that task ends: naming it in a router move, in a
new server (public_ipv4: {"id": N}) or in a network interface change answers 409 ip_in_use,
and public_ipv4: {"reuse": true} picks the next free address instead. After a failed move that left the
router answering on the new address while the records do not show it there, the address stays held for up to an
hour: a release, another server and another router get 409 ip_in_use; repeating the move of that same
router is accepted and finishes it.
What stays the same. The success code of the move (202 with a task) and its response body. The
refusals checked before anything changes still come as the answer: 422 for an address of another subnet,
409 ip_in_use for an address on a server, 404 ip_not_found, and
503 router_unreachable when the router does not answer or its port forwards cannot be read - unless the
router already answers on the requested address after an interrupted move: then the call answers 202
and the task finishes that move. Repeating a move that is already done answers 200 with
task: null.
What to do. Wait for the task before you rely on the new address and branch on its error.code:
after router_unreachable or router_apply_failed, read the router and repeat the call if you
still want the move; after operation_failed, read message and the router. On
409 server_busy, wait as Retry-After says and repeat with the same idempotency key; on
409 ip_in_use for an address that is free in GET /v1/ips, wait for the task that is attaching
it or pick another address. If your client is generated from the OpenAPI description and rejects fields it does not
know, regenerate it: a task's error may now carry message.
Terraform. The provider does not manage a router's public address. A server or network interface that names
an address another task is attaching fails with ip_in_use; apply again once that task has finished.
2026-10-15 - Changed: power events of a service suspension carry initiator and reason
Endpoint: GET /v1/servers/{id}/events
What changed. When the service is suspended, the platform asks its running servers to power
off, and when the suspension is lifted, it asks the ones that were running before to power on. These
two actions still come as ordinary power_off and power_on events, and now carry
two more fields: initiator with the value platform, and reason with
service_suspended or service_resumed. Other events come without these fields -
the keys are absent, not null. The power_on of a lifted
suspension now ends failed when the platform got an explicit refusal of the start; before,
it always ended succeeded.
What stays the same. The event types and their list, time, type and
status are unchanged. The status of these events does not tell what the server did: on
service_suspended, succeeded means the power-off was requested, not that the
server has stopped; on service_resumed, succeeded means no refusal of the start
was recorded. When the start runs as a separate queued task, it still shows up a few seconds later as
a second, ordinary power_on without the new fields. Some servers get no event: a few are
not covered by a suspension and keep running; a server that was already off stays off when the
suspension is lifted; a server that is busy at that moment can stay off after the suspension is lifted.
Why the service was suspended is not stated.
What to do. If your code keeps track of a server's power from this feed, nothing breaks:
suspension and lifting are still power_off and power_on. To tell them from your
own actions, read initiator and reason; both are strings without a fixed list,
so treat a value you do not know as informational. Do not take the power state from these events
alone: after a service_suspended or service_resumed event, read the server with
GET /v1/servers/{id} - status and power show what it did - and, once the
project is active again, power on the servers you need that stayed off. A plain power_on a few seconds
after a service_resumed one is the same start, not a second one. If your client is
generated from the OpenAPI description and rejects fields it does not know, regenerate it.
Terraform. The provider does not read the event feed; no change needed.
2026-10-12 - Changed: adding SSH keys is refused on Windows servers
Endpoint: POST /v1/servers/{id}/actions/add-ssh-keys
What changed. On a server created from a Windows image of the catalogue, or from your own
image taken from such a server, the action now answers ssh_keys_unsupported (409) before
anything happens: no task is created and the server is not restarted. Before, the request was
accepted, a running server was restarted to apply the keys, and the task ended succeeded,
yet the keys gave no way in: Windows has no running SSH server. Windows you installed yourself from an
ISO, and your own image taken from such a server, are not recognised up front: the request is still
accepted, and if the server's guest agent answers, the task now ends failed and the server
is not restarted, where before it was restarted and the task ended succeeded. On any server,
if the platform cannot read the server's settings at that moment, the request is refused with
server_unavailable (503) before anything happens.
What stays the same. Linux servers get the keys as before. On Windows installed from an ISO
whose guest agent does not answer, the request goes through as before: a running server is restarted
to apply the keys, the task ends succeeded, and the keys still give no way in. A server that
is busy with another operation is refused with server_busy (409), as before.
What to do. On any Windows server, sign in as Administrator with the server password over
Remote Desktop (RDP); POST /v1/servers/{id}/actions/reset-password sets a new one. Repeating
a request refused with ssh_keys_unsupported does not help. After server_unavailable,
repeat the request a little later.
Terraform. The provider does not call add-ssh-keys; no change needed.
2026-10-12 - Changed: private addresses report available: false when the guest agent does not answer
Endpoint: GET /v1/servers/{id}/private-ips
What changed. When the guest agent inside the server does not answer - it is not installed,
it is stopped, or the server is not running - the response is now
{"available": false, "interfaces": {}}. Before, in this case the response said
available: true and listed the server's private network cards with empty lists, for
example {"available": true, "interfaces": {"net1": []}}, which looked the same as an agent
that answered and saw no address.
What stays the same. When the agent answers, the response is as before:
available: true and, for each private network card without a platform-assigned address
(net1 and so on, or net0 on a server without a public address), the IPv4 addresses the agent sees on it - an empty list if it sees none. A server with no such card
answers {"available": true, "interfaces": {}} without asking the agent, as before.
What to do. If your code reads interfaces without checking available,
check available first: false means "unknown right now", not "no addresses".
Start the agent inside the server (on Linux, the qemu-guest-agent service) or wait until
the server has booted, then read again. If the agent stopped answering on a server that had been
running for 10 minutes or more, the response may stay available: false for up to
10 minutes after the agent answers again. If your code already checks available, it now
gets the answer it expected.
2026-10-12 - Changed: the creation task of a server deleted while it was being created fails with server_deleted
Endpoints: GET /v1/tasks/{id} for the task returned by POST /v1/servers
What changed. If a server is deleted while it is still being created - from the client
area or by support - its creation task now ends
failed with error.code server_deleted. Before, it ended
failed with operation_failed, which tells you to repeat the operation. The same
code is given if the server was created and then deleted before anyone read its task.
What stays the same. Any other failure of a creation still ends with
operation_failed. A task that already has its final state keeps it: a task that ended
succeeded or failed earlier is not changed. Through the API a server cannot be
deleted while it is being created (DELETE answers server_busy), so this code
comes from deletions made elsewhere.
What to do. Treat server_deleted as final: there is nothing to repeat, and the
server no longer exists. Create a new server if you still need one. Treat any code you do not know
as operation_failed.
Terraform. The provider reports the task code in its error text, so a creation that hits
this case now says (server_deleted) instead of (operation_failed).
2026-10-12 - Changed: an SSH key name that differs from an existing one only in letter case or accents is refused
Endpoint: POST /v1/ssh-keys
What changed. Key names in your pool are compared without letter case and accents:
deploy and Deploy, cafe and café count as the same
name. If you send a name that matches an existing key this way but is spelled differently, the
request is now refused with ssh_key_name_taken (409), whatever the key material, and
detail names the existing key. Before, when the material was the same, the request
answered 200 with the existing key under its own spelling, so the name in the response differed from
the name you sent.
What stays the same. The same name spelled exactly the same, with the same material,
returns the existing key with 200. The same name with different material is refused with
ssh_key_name_taken, as before. Names that differ in anything else are separate keys.
What to do. Use the exact name of the existing key, as detail or
GET /v1/ssh-keys shows it, or choose a different name.
Terraform. A fiberax_ssh_key whose name differs from a key already in the pool
only in letter case or accents now fails on apply instead of adopting that key under its other
spelling. The provider's message says the key has different material; the detail after it gives the real
reason. Set name to the exact spelling of the existing key, or use another name.
2026-10-12 - Changed: the response to deleting a disk declares its fields required
Endpoint: DELETE /v1/servers/{id}/disks/{disk}
What changed. In the OpenAPI description, deleted and server_id of the
DiskDeleted response are now listed as required. The API has always returned both fields;
only the description changed. A client generated from the new description gets them as non-optional
fields.
What stays the same. The response itself, its status codes (202 with a task, 200 without one) and the deletion are unchanged.
What to do. Nothing, unless you generate a client from the description: after regenerating, code that handled these fields as possibly missing can drop that check.
2026-10-05 - Removed: plan_* lines in server type pricing
Endpoint: GET /v1/server-types/{id}/pricing
What changed. On server types sold as plans (pricing_mode: plans),
metered carried one line per plan, keyed plan_<key> (for example
plan_l0), each with hourly: 1 and monthly: 720. Those lines were
internal billing multipliers, not prices, and the response no longer includes them.
What stays the same. Every other line of metered - maxcpu_on,
maxmem_on, maxdisk, ipv4_addresses, the Windows licence lines and
backup_gb - and the rest of the response are unchanged. Billing is unchanged.
What to do. Everything about a plan is in plans of the same response: its
price (per month), cores, memory_gb and disk_gb, and the
id you send as plan_id. If your code reads a plan_<key> line
from metered, take the plan's price and size from plans instead. If your code
walks metered and skips plan_ keys, nothing changes for you. Cost lines in
GET /v1/project/costs keep their sku plan_<key>, but that key no longer
has a line in metered. If your code looked up metered[sku] for a plan's cost
line, it no longer needs a rate: the line's amount is already the charge. To tell which
plan it is, use GET /v1/project/costs/servers - its plan lines carry the same sku and are
named as the plan in plans.
Terraform. In the fiberax_server_type_pricing data source, metered no
longer has plan_<key> entries. A reference such as metered["plan_l0"] now
fails with an invalid index error; read plans instead.
2026-10-04 - Changed: deleting a server releases its public addresses by default
Endpoint: DELETE /v1/servers/{id}
What changed. Deleting a server now releases its public IPv4 addresses by default: once the
deletion task succeeds, every public address attached to the server - a router's external address
included - goes back to the platform's shared pool and is no longer billed. Releasing cannot be
undone: a released address cannot be taken back, and another customer may receive it. Before this
change the addresses stayed with the project, attached to nothing, and kept being billed until
released with DELETE /v1/ips/{id}. The new query parameter release_ips
chooses: true (the default, also when the parameter is left out) releases,
false keeps the addresses with the project as before. Accepted values are
true and false in any letter case, and 1 and 0, given
once; anything else - an empty value, or the parameter given more than once - is refused with
invalid_request (422) and nothing is deleted. The response gains two fields next to
billable_ips: released_ips lists the addresses that go back to the pool when
the task succeeds, and release_ips is the choice the deletion task applies. Every public
address the server had when the request was accepted is in exactly one of released_ips
and billable_ips; the lists are a snapshot of that moment, and GET /v1/ips
after the task is the record of what the project still holds.
What stays the same. If the deletion fails (its task ends failed), nothing is
released: the server and all its addresses stay as they were, as before. With
release_ips=false the addresses are kept and billed exactly as before: they are listed in
billable_ips and billed every hour, like any address the project holds with no server
attached, until you release them - the description of DELETE /v1/servers/{id} in the
reference says at which rate and where the charge is listed. A DELETE
sent while a deletion of the same server is already running still joins it and answers with its
task; that running deletion decides about the addresses, and the response now says which way in
release_ips (null when its choice could not be determined - the addresses are
then listed in billable_ips, although that deletion may still release them). Removing a
network card and moving a card to a private network do not release addresses: they stay with the
project and are listed in billable_ips, as before. An Idempotency-Key repeated
with a different release_ips is refused with idempotency_key_reused (422);
release_ips=true is the same request as no parameter, and false the same as
0.
What to do. If you want to keep a server's addresses - a DNS record points at them, or you
will give them to the next server with public_ipv4 {"id": N} or
{"reuse": true} - send DELETE /v1/servers/{id}?release_ips=false. If your code
released the addresses from billable_ips with DELETE /v1/ips/{id} after
deleting a server, it no longer needs to: those addresses are now in released_ips and go
back to the pool by themselves; a DELETE /v1/ips/{id} for one of them after the task
answers ip_not_found (404). After the task succeeds, check GET /v1/ips: an
address from released_ips that is still listed was not released (rare - for example, it
was attached to another server in the meantime); it stays with the project and is billed until you
release it.
Terraform. Provider 0.7.0 and later (0.7.1 to 0.7.3 change only texts and warnings) tell
the platform what to do on every destroy. A server with public_ipv4 = { new = true }, when it is
destroyed or replaced, releases every public address it holds at that moment, including ones
attached outside the configuration. A server with { id = ... } or
{ reuse = true }, and a server without the block (an imported one included), keeps its
addresses with the project, as before. Versions 0.6.0 and earlier do not send the parameter, so with
them destroying or replacing a server releases every address it holds - including one named with
id, which a replacement would otherwise move to the new server. Upgrade to 0.7.0 or later
(version = "~> 0.7.0") before you destroy or replace a server. To keep the address of a
server created with new = true, do not switch it to id or
reuse = true: that replaces the server, the replacement releases the address first, and
the provider refuses such a plan. Remove the public_ipv4 block instead - the address then
stays with the project, still billed - and import it as fiberax_ip to manage it; the guide
Public addresses and what they cost gives the
steps. Replacing a server with new = true releases its address first; the replacement then
takes a free address from the shared pool, which may or may not be the same one - do not rely on
keeping it.