A server from start to finish
One continuous run, in the order you would actually do it: a private network, a server with a public address, the firewall in front of it, a backup, and then a clean-up that leaves nothing billable behind. Getting started covers the first token and the first call - this guide assumes you have both.
Every call below was run against a live project. Identifiers in the answers are made up; yours will differ.
1. See what you are working in
curl -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/project
{ "data": { "id": 4711, "name": "my-project", "status": "Active" } }
A token belongs to one project, so this also tells you which project you are about to change. A
suspended project still answers reads, and so does a project whose owner has an overdue invoice;
both refuse most changes with 402 - money rather than rights - and both allow the same
short list: deleting (servers, disks, network interfaces, backups, addresses, networks, SSH keys,
images, router rules, port forwards and VPN devices), detaching a router from a network, ejecting an
ISO image, server tags, and switching automatic backups or a router's VPN tunnel off. You can always
take down what you pay for. Power actions are not on the list - switching a server off included:
when a project is suspended, the platform asks its running servers to power off (some servers are not
covered and keep running - a server's status shows which), and with an overdue invoice you stop the
charges for a server by deleting it. The full list is on the pages of the two codes,
client_has_debt and
service_suspended.
2. A private network
Servers talk to each other over a private network. You get one by default; make your own when you want a separate address range:
curl -X POST -H "Authorization: Bearer $FBX_TOKEN" \
-H "Content-Type: application/json" \
-d '{"name":"backend","cidr":"10.42.0.0/24"}' \
https://api.fiberax.com/v1/networks
{ "data": null,
"task": { "id": "0cd9cb...", "status": "pending", "is_terminal": false,
"poll": "/v1/tasks/0cd9cb..." } }
The network does not exist yet when this returns, and the answer carries no identifier - unlike a server, which is given its number immediately. The work happens on the platform and takes about two minutes, longer when the platform queue is busy. Poll the task, then list the networks to learn the new identifier:
curl -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/networks
{ "data": [
{ "id": 325, "name": "Default Network", "cidr": "10.0.0.0/24", "is_default": true,
"server_count": 0, "router": null },
{ "id": 601, "name": "backend", "cidr": "10.42.0.0/24", "is_default": false,
"server_count": 0, "router": null } ] }
3. A server with a public address
Ask for a fresh public address in the same call. The size fields depend on the type - a slider
type takes cores, memory_mb and disk_gb, a plan type takes
plan_id instead. The two do not mix: on a plan type the size fields are refused with
resources_managed_by_plan (422) - there the plan sets cores, memory and disks, so to change
the size you change 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). GET
/v1/server-types/{id}/pricing tells you which kind a type is and lists its plans:
curl -X POST -H "Authorization: Bearer $FBX_TOKEN" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: backend-01-2026-09-16" \
-d '{
"name": "backend-01",
"server_type_id": 4,
"image": "fcf9f69c8630904c1d6d73a821f4e674",
"cores": 1,
"memory_mb": 1024,
"disk_gb": 10,
"public_ipv4": { "new": true },
"ssh_keys": [126]
}' \
https://api.fiberax.com/v1/servers
The server comes back as creating, and the address it received is already in the
answer:
{ "data": { "id": 11199, "name": "backend-01", "status": "creating", "power": false,
"ipv4": "203.0.113.24",
"ips": [ { "id": 56, "address": "203.0.113.24", "prefix": "/26",
"gateway": "203.0.113.1", "server_id": 11199, "primary": true } ] },
"task": { "id": "89cc0d...", "status": "pending", "is_terminal": false } }
Fields omitted for brevity.
Two things are worth doing here rather than later. Send an Idempotency-Key: if
the connection drops and you repeat the call with the same key, you get the same server back instead
of a second billable one. Note the other side of that: a refusal about the request itself is
remembered under the key as well, so after fixing such a request you need a NEW key - repeating with
the old one returns the old refusal. A 409 or a 402 is not remembered: fix
what it names and repeat with the same key. Prefer {"reuse": true} to {"new": true}
once your project has addresses of its own: it takes a free address you already pay for, and only
allocates a new one when there is none.
4. Put it on the private network
A server created with a public address has one card. Add a second one on the network from step 2. Adding a card restarts a running server: the task changes the server's network settings, and that takes a short cold restart. Plan for it on a server that already serves traffic. Removing a card that carries no addresses happens without a restart.
curl -X POST -H "Authorization: Bearer $FBX_TOKEN" \
-H "Content-Type: application/json" \
-d '{"network_id":601}' \
https://api.fiberax.com/v1/servers/11199/network-interfaces
{ "data": { "id": "net1", "public": false, "network_id": 601, "firewall": false, "ips": [] },
"task": { "id": "3ed69d...", "status": "pending", "is_terminal": false } }
Fields omitted for brevity.
The card is named by the platform (net0, net1, ...), and that name is
what you use everywhere else. Reading the cards back shows both:
curl -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/servers/11199/network-interfaces
A private network hands out addresses only through a router attached to it. The platform
itself does not assign them: the new card asks for an address over DHCP, and only a router answers.
Without a router the servers are connected, but get no IPv4 address on that card - set one inside
the operating system yourself (a server with no public card is reached for that through its console
in the client area, or from a neighbour on the same network by its link-local IPv6 address,
fe80::...), or attach a router to the network (on a /24 it hands out addresses from
.64 up). The card's ips stays empty on a private network either way; the address a server
actually received is read from GET /v1/servers/{id}/private-ips, which asks the guest
agent.
5. The firewall
The firewall is a state, not a list of commands: you send the whole set of rules you want, and
that is what the server ends up with. It filters the PUBLIC card only - traffic inside a private
network is not touched by it. Reading it always works; switching it ON for a server that has no
public card answers firewall_no_public_iface (409), because there would be nothing to
filter. Read it first - an empty answer is normal for a new server:
curl -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/servers/11199/firewall
{ "data": { "enabled": false, "policy_in": "drop", "policy_out": "accept", "rules": [] } }
Fields omitted for brevity.
Now let SSH and web traffic in, and drop the rest. Switching the firewall on takes both policies
by name - policy_in for traffic coming in, policy_out for traffic going
out: a request that leaves one out is refused with invalid_request (422) naming the
field, and nothing on the server changes.
curl -X PUT -H "Authorization: Bearer $FBX_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"enabled": true,
"policy_in": "drop",
"policy_out": "accept",
"rules": [
{"direction":"in","action":"accept","enabled":true,"protocol":"tcp",
"destination_port":"22","description":"ssh"},
{"direction":"in","action":"accept","enabled":true,"protocol":"tcp",
"destination_port":"80,443","description":"web"}
]
}' \
https://api.fiberax.com/v1/servers/11199/firewall
Order matters: the first matching rule wins. The note on a rule is called
description; if you call it something else, the answer says so instead of dropping the
field quietly:
{ "status": 422, "code": "invalid_request",
"invalid_params": [ { "name": "rules", "reason": "item 0 contains an unknown field" } ] }
Neither rule names an address, and that is deliberate. A server with a public address normally
has a global IPv6 address too: its operating system takes one from the datacenter network on its
own (SLAAC), and the server's ipv6 field does not show it. The firewall judges IPv4 and
IPv6 separately - a rule without an address covers both, a rule with an address covers only that
address's family. So a drop from 0.0.0.0/0 under "policy_in": "accept"
closes the port over IPv4 and leaves it open over IPv6. To let one office in and keep everyone
else out, put the accept with the office address first and the drop without an address after it.
The policies cover both families, which is why "policy_in": "drop" above shuts
everything else over IPv6 as well. To let ping in, mind that icmp is ICMP over IPv4
only: ping over IPv6 needs a second rule with ipv6-icmp.
6. A backup before you change anything
curl -X POST -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/servers/11199/backups
{ "data": { "id": "2026-09-16T02:59:49Z", "server_id": 11199, "status": "creating",
"size_bytes": null, "created_at": "2026-09-16T04:59:49+02:00" } }
This call takes no body. The backup is identified by the moment it was taken, and that identifier
is what you pass to restore or delete it. It is ready in well under a minute for a small disk.
A backup reads only the blocks that changed since the previous one while the server has kept running
in between - a reboot from inside the operating system does not break that. The first backup of a
server, a backup of a stopped server, and the first backup after the server was stopped and started
again - a reboot through the API, a stop and start, a restore, or any change that restarts the
server - read the whole disk, so their time grows with the disk size: on a GPU server with a
1600 GB disk that is about ten minutes, and the server answers 409 server_busy to
changes and power actions until the backup is done.
This is the one operation that does not come with a task, so watch the backup itself: read the
list until its status turns from creating to available, and
size_bytes stops being empty.
curl -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/servers/11199/backups
Backups are billed per server, not per backup. While automatic backups are on, a server pays
20% of what it costs, every hour, however many backups are kept and however large they are. On a
slider type that is 20% of its cores, memory, disk and Windows licence (counted for at least 8 cores, as it is billed) at the type's rates -
maxcpu_on, maxmem_on, maxdisk and license_* in
GET /v1/server-types/{id}/pricing - whether the server runs or not; on a slider type with
GPUs the cards are not part of it. On a plan type (Solo) it is 20% of the plan's monthly price plus the
Windows licence, rounded up to a whole euro with a minimum of EUR 2 a month and charged by the hour: a
EUR 64 plan pays EUR 13 a month for backups. A packaged GPU server pays its package's flat
backup_price per month instead. The backup_gb line in
GET /v1/server-types/{id}/pricing, on every type that lists it, is a billing multiplier, not the
price of backups and not a price per gigabyte: backups cost 20% of what the server costs, or the package's
backup_price on a type that sells GPU packages, as above. Automatic backups are on by default for every new
server of a project, from its first hour. Switch them off per server
(PUT /v1/servers/{id}/backup-policy) or for the whole project
(PUT /v1/project/backup-policy). Deleting backups does not lower the bill; switching them
off does. A deleted server pays for no backups at all.
Your project may already be taking backups on a schedule. Read the policy of this server to see when the next one is due:
curl -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/servers/11199/backup-policy
{ "data": { "enabled": true, "days": ["mon","tue","wed","thu","fri","sat","sun"],
"times": ["01:25"], "timezone": "Europe/Warsaw", "hour": 1, "minute": 25, "keep": 7,
"next_run": "2026-09-17T01:25:00+02:00", "last_run": null } }
Fields omitted for brevity.
A server can take up to four backups a day: send times, for example
{"enabled": true, "times": ["03:00", "15:00"]}. The times are in the zone named by
timezone and must be at least two hours apart. The server keeps keep backups
however often they are taken, so more backups a day means a shorter history.
A backup you take counts toward keep. The server keeps that many backups in
total, scheduled and on-demand alike: once it holds more, the oldest are deleted within about an
hour, whichever way they were taken. On a server that already holds keep backups, the
one you take now pushes out the oldest, and each scheduled run after it moves your backup one step
closer to deletion - restore from it, if you need to, before keep newer backups exist.
7. Before you delete it: the backups
Backups belong to their server. Once the server is deleted, its backups can no longer be listed,
restored or deleted through this API - every backup path starts with the server, and a deleted
server answers server_not_found (404). They stop being billed, and the platform erases
them on its own once the backup retention period runs out. So decide while the server still
exists:
- You may need the data. Restore the backup, or copy what you need off the server, now.
Restoring cannot be undone. It rolls back every disk the backup contains - contents and size; on a server sold as a plan, a system disk smaller than the plan's is then grown back to the plan's size, and the plan stays. Data disks added after the backup are kept (unless one took a disk id the backup had); a disk deleted after the backup comes back. Name, cores, memory, network, firewall and tags stay as they are now. A running server is stopped and started again, a stopped one stays stopped. Wait for the task, then read the server.
- You want nothing kept. Delete the backups now rather than leave them, until the retention period runs out, where you can no longer reach them:
curl -X DELETE -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/servers/11199/backups/2026-09-16T02:59:49Z
Answered with a task. A scheduled backup due before the deletion is still taken, so read the list once more right before step 8.
8. Delete the server
Deleting a server releases its public addresses by default: once the deletion succeeds, they go back to the platform's shared pool. A released address cannot be taken back, and another customer may receive it. Decide before you send the request:
- You no longer need the address - send the plain request below. Nothing is left behind and nothing more is billed for it.
- You want to keep the address (a DNS record points at it, or you will give it to the next
server) - add
?release_ips=false. The address then stays with your project, attached to nothing, and is billed every hour until you release it (step 9) - as any address your project holds with no server: at theipv4_addressesrate of your project's home server type, not of the deleted server's type; a type with noipv4_addressesrate in its pricing does not bill addresses. The API does not name the home type, and it does not need to today: every server type that bills addresses has the same rate, 0.00278 EUR an hour per address (2.00 EUR a month at the hourly rate times 720). The charge for addresses with no server is listed inGET /v1/project/costs/serversunderunattached(empty when they cost nothing); inGET /v1/project/costsit is part of a skuipv4line, merged with addresses on servers of the home type.
curl -X DELETE -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/servers/11199
{ "data": { "server_id": 11199,
"release_ips": true,
"released_ips": [ { "id": 56, "address": "203.0.113.24", ... } ],
"billable_ips": [] },
"task": { "id": "e3cb0d...", "status": "pending", "is_terminal": false } }
Fields omitted for brevity.
Read the answer. released_ips are the addresses that go back to the pool when the
task succeeds; billable_ips are the ones your project keeps and keeps paying for. Every
address the server had when your request was accepted is in exactly one of the two lists, and
release_ips says which way the deletion goes. With ?release_ips=false the same address would be in
billable_ips and released_ips would be empty.
If the deletion fails (the task ends failed), nothing is released: the server and its
addresses stay as they were. If a deletion of the same server was already running when you sent yours
- started in the client area, say - your request is not refused: it joins that deletion (202 with its
task; only a request sent while the first one is still being submitted gets 409 server_busy
- repeat it), and that deletion decides about the addresses - your release_ips cannot
change it. release_ips then shows its choice, which may not be yours (a deletion from the
client area releases the addresses unless whoever started it chose to keep them; one by support from the
operators' admin area (not the client area) keeps them). When it reads null,
that choice is unknown and the addresses are listed in billable_ips, although the running
deletion may still release them; an address it detached before your request was accepted was no
longer the server's, so it is in neither list. Either way,
read GET /v1/ips after the task to see which ones your project still holds.
9. Check the addresses
Wait until the task is over, then list the addresses your project holds. The delete answer is a snapshot of the moment it was accepted; this list is the record of what your project holds now:
curl -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/ips
An address from released_ips is no longer there. If it still is, it was not released
(rare - for example, it was attached to another server in the meantime): it stays with your project and
is billed. An address you kept with ?release_ips=false is there with
"server_id": null:
{ "data": [ { "id": 56, "address": "203.0.113.24", "server_id": null, "primary": false } ] }
Fields omitted for brevity.
An address with "server_id": null is attached to nothing and still costs money. Give it
to the next server ({"reuse": true} or {"id": 56} in
public_ipv4), or release it once you no longer need it:
curl -X DELETE -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/ips/56
{ "data": { "deleted": 56 } }
10. And the network
curl -X DELETE -H "Authorization: Bearer $FBX_TOKEN" \
https://api.fiberax.com/v1/networks/601
Answered with a task, like the creation was. A network with servers still on it is refused - take the cards off first.
What to keep in mind
- Deleting a server releases its public addresses unless you send
release_ips=false, and a released address cannot be taken back. Addresses you keep stay billed until you release them; the delete answer names both kinds. Backups outlive the server, but out of reach: they can no longer be listed, restored or deleted, are not billed, and are erased when the retention period runs out - deal with them before the deletion. - Tasks tell you the work is over, resources tell you what it came to. Poll the task
until
is_terminal, then read the resource. A task that endsfailed(erroroperation_failed) means the change did not go through. Usually nothing changed at all, but not always, so read the resource to see where it stands: a plan change can stop after growing the disk and before the cores and memory, and a failed deletion normally leaves the server running and billed. A new password or SSH key is the one change a task cannot show you from the outside: without a running guest agent it goes to cloud-init and takes effect when the server boots - at the reboot the task arranges, or at the next start of a stopped server - so log in to be sure. - A server sets up one public address per card by itself. The platform configures inside
the server only the card's main address (on
net0, the one markedprimary). An extra address you attach to the card withPATCH /v1/servers/{id}/network-interfaces/{interface}is routed to the server and billed, but works only once you add it inside the operating system - the same netmask as the main address, and no second gateway. Adding or taking off an extra address does not restart the server; moving the card to another network or changing its main address restarts a running server once. - A plan change needs a stopped server. Changing
plan_idgoes up only and resizes cores, memory and the system disk while the machine is down, so on a running server a real upgrade answersserver_not_stopped(409): power it off, wait for the task, and repeat the same request with the sameIdempotency-Key. Refusals on the substance come first and at any power state - an unknown plan isplan_not_found(404), a smaller oneplan_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. - Repeat safely. Send an
Idempotency-Keyon every create. A repeat with the same key returns the first answer instead of doing the work twice. - 409 means the state is in the way. Usually you change something and repeat; sometimes
the resource is simply held by a neighbour, and then
Retry-Aftersays how long to wait. Some refusals deliberately carry no such header, because waiting would not help - no free GPU capacity is one of them. Operations on one server, one network or one router are queued, and so are address allocation and image uploads across the project - a parallel script of your own can be the reason you see 409; work on different servers does not wait for each other. A503means we could not do it right now: the request was fine, try again later.