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:

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:

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