This guide provides a systematic diagnostic procedure for connection failures between FICSIT.monitor and your Satisfactory server. Work through the steps in order to isolate the root cause.

Quick Diagnostic Flowchart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Is the server container running?
  └── No → docker start satisfactory-server, wait 2 min
  └── Yes ↓

Does HealthCheck respond?
  └── No → Port 7777 is blocked or server crashed → Step 1
  └── Yes ↓

Does PasswordLogin succeed?
  └── No (wrong_password) → Admin password is wrong → Step 2
  └── Yes ↓

Does FRM respond?
  └── No → Port 8080 blocked or FRM not installed → Step 3
  └── Yes ↓

All checks pass → contact support

Step 1: Verify Server is Running and Port 7777 is Open

Check Docker container

1
docker ps | grep satisfactory

Expected: shows Up X hours or Up X minutes.

If not running:

1
2
3
docker start satisfactory-server
docker logs -f satisfactory-server | grep "InProgress"
# Wait for "LogGameState: Match State Changed from WaitingToStart to InProgress"

Check port 7777 is listening

On the server:

1
ss -tulnp | grep 7777

Expected output:

1
2
tcp  LISTEN  0  100  0.0.0.0:7777  0.0.0.0:*  users:(("FactoryServer",pid=xxx,fd=x))
udp  UNCONN  0  0    0.0.0.0:7777  0.0.0.0:*  users:(("FactoryServer",pid=xxx,fd=x))

If nothing appears, the game server process is not running. Check Docker logs for errors.

Check UFW allows port 7777

1
sudo ufw status | grep 7777

Expected:

1
2
7777/tcp  ALLOW Anywhere
7777/udp  ALLOW Anywhere

If missing:

1
2
3
sudo ufw allow 7777/tcp
sudo ufw allow 7777/udp
sudo ufw reload

Test the vanilla API (from an external machine)

Run this from your local PC (not from the server itself):

1
2
3
curl -k -X POST https://YOUR_PUBLIC_IP:7777/api/v1 \
  -H "Content-Type: application/json" \
  -d '{"function":"HealthCheck","data":{}}'

• ✅ {"data":{"health":"healthy"}} — Port 7777 is accessible externally. Proceed to Step 2.
• ❌ Connection refused — The game server is not running or port 7777 is blocked externally.
• ❌ Connection timed out — Port 7777 is blocked by a firewall (cloud security group or VPS provider firewall).
• ❌ SSL: certificate verify failed — Normal. Add -k flag to ignore the self-signed certificate.

Step 2: Verify the Admin Password

1
2
3
4
5
6
7
8
9
curl -k -X POST https://YOUR_PUBLIC_IP:7777/api/v1 \
  -H "Content-Type: application/json" \
  -d '{
    "function": "PasswordLogin",
    "data": {
      "minimumPrivilegeLevel": "Administrator",
      "password": "YourAdminPassword"
    }
  }'

• ✅ {"data":{"authenticationToken":"..."}} — Password is correct. Proceed to Step 3.
• ❌ {"errorCode":"wrong_password"} — Incorrect password.

Fix for wrong password:

1. Connect from game client
2. Go to Escape → Server Settings → Administration
3. Reset the admin password
4. Update the password in FICSIT.monitor

If you’ve forgotten the admin password and cannot connect from the game client:

1. Stop the container: docker stop satisfactory-server
2. Open ./data/config/GameUserSettings.ini
3. Find AdminPassword= and reset it
4. Start the container: docker start satisfactory-server

Step 3: Verify FRM is Running

1
curl http://YOUR_PUBLIC_IP:8080/getPower

• ✅ JSON array (may be empty []) — FRM is running. If [], no session is active yet (start a game).
• ❌ Connection refused — FRM is not running or port 8080 is blocked.
• ❌ Connection timed out — Port 8080 is blocked by the cloud firewall.

Fix for FRM not accessible:

1. Open port 8080 in UFW:

   1
   2
   3
   sudo ufw allow 8080/tcp
   sudo ufw allow 8081/tcp
   sudo ufw reload
   

2. If using a cloud provider, open ports 8080 and 8081 TCP in the cloud firewall / security group.

3. Verify FRM is installed. From outside the game, you can check via the vanilla API:

   1
   2
   3
   4
   curl -k -X POST https://YOUR_PUBLIC_IP:7777/api/v1 \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer YOUR_TOKEN" \
     -d '{"function":"frm","endpoint":"getPower"}'
   

If FRM is installed but port 8080 is blocked, this alternative endpoint still works.

Step 4: Cloud Provider Firewall Checks

If UFW is configured correctly but external connections still fail, your cloud provider may have a separate firewall that overrides UFW.

Hetzner Cloud:

• Go to Cloud Console → Firewalls
• Verify your server’s firewall includes inbound rules for TCP 7777, UDP 7777, TCP 8888, TCP 8080, TCP 8081

DigitalOcean:

• Go to Networking → Firewalls
• Verify the Droplet’s firewall allows the required ports

AWS:

• Go to EC2 → Security Groups
• Verify inbound rules include TCP 7777, UDP 7777, TCP 8888, TCP 8080, TCP 8081 from 0.0.0.0/0

Step 5: Verify the IP is Public

FICSIT.monitor’s servers connect to your server from the internet. Common mistake: using a private or local IP.

1
2
3
4
# Check your server's public IP
curl ifconfig.me
# or
curl api.ipify.org

The public IP shown here is what you should enter in FICSIT.monitor — not localhost, not 192.168.x.x, not 10.x.x.x.

Still Not Working?

Gather this diagnostic information before seeking support:

1. Output of docker ps | grep satisfactory
2. Output of curl -k -X POST https://YOUR_IP:7777/api/v1 -H "Content-Type: application/json" -d '{"function":"HealthCheck","data":{}}'
3. Output of curl http://YOUR_IP:8080/getPower
4. Output of sudo ufw status
5. The exact error code shown in FICSIT.monitor (422, 502, or 500)

This page covers the most common errors encountered when setting up or using FICSIT.monitor, with their causes and step-by-step fixes.

FICSIT.monitor Error Codes

422 — Wrong Admin Password

Error: InvalidAdminPasswordException

Cause: The admin password you provided when adding the server does not match the password set on the Satisfactory server.

Fix:

1. Connect to your server from the game client
2. Go to Escape → Server Settings → Administration
3. Note the admin password (or reset it to a known value)
4. In FICSIT.monitor, go to your server → Edit → update the admin password
5. Retry adding or reconnecting the server

Verify the password manually:

1
2
3
curl -k -X POST https://YOUR_IP:7777/api/v1 \
  -H "Content-Type: application/json" \
  -d '{"function":"PasswordLogin","data":{"minimumPrivilegeLevel":"Administrator","password":"YOUR_PASSWORD"}}'

If this returns {"errorCode":"wrong_password"}, the password is incorrect.

502 — Server Unreachable

Error: ServerUnreachableException

Cause: FICSIT.monitor cannot establish a TCP connection to your server on port 7777.

Fix checklist:

1. Verify the server container is running:

   1
   2
   docker ps | grep satisfactory
   # Should show "Up X hours"
   

2. Verify the server is listening on port 7777:

   1
   2
   ss -tulnp | grep 7777
   # Should show: 0.0.0.0:7777
   

3. Verify the port is open in UFW:

   1
   2
   sudo ufw status | grep 7777
   # Should show: 7777/tcp ALLOW Anywhere
   

4. Test from an external machine:

   1
   2
   3
   4
   curl -k -X POST https://YOUR_PUBLIC_IP:7777/api/v1 \
     -H "Content-Type: application/json" \
     -d '{"function":"HealthCheck","data":{}}'
   # Expected: {"data":{"health":"healthy"}}
   

5. Verify the IP in FICSIT.monitor is the public IP — not localhost, 127.0.0.1, or a private IP like 192.168.x.x.

500 — Provisioning Failed

Error: ProvisioningFailedException

Cause: FICSIT.monitor connected to the server (port 7777 is OK), authenticated (password is correct), but something failed during the setup phase. Usually caused by FRM not being accessible on port 8080.

Fix checklist:

1. Verify FRM is running:

   1
   2
   3
   curl http://YOUR_PUBLIC_IP:8080/getPower
   # Expected: JSON array
   # If "Connection refused": FRM not running or port 8080 not open
   

2. Open port 8080 in UFW:

   1
   sudo ufw allow 8080/tcp && sudo ufw reload
   

3. Verify FRM is installed (restart server after installing):

   1
   2
   3
   docker restart satisfactory-server
   # Wait ~2 minutes for the server to come back online
   curl http://YOUR_PUBLIC_IP:8080/getPower
   

FRM-Specific Issues

FRM Shows No Data (Empty Array)

Symptom: curl http://YOUR_IP:8080/getPower returns []

Cause: The server is running but no game session is active (no world loaded).

Fix: Connect from the game client and start or load a game session.

FRM Not Installed

Symptom: curl http://YOUR_IP:8080/getPower returns Connection refused

Fix:

1. Install FRM via Satisfactory Mod Manager (see Installing FRM)
2. Restart the server container: docker restart satisfactory-server
3. Wait for the server to come back online and retry

FRM Data Stops Updating

Symptom: Dashboard panels show data, but it’s not changing

Cause: The background polling jobs may have stopped.

Fix: Check the Laravel Horizon queue worker status. In Kubernetes, check the Horizon deployment pod is running. In Docker, this would require the full application stack (not just the game server).

Dashboard Issues

Dashboard Shows Stale Data

Symptom: The dashboard isn’t updating automatically

Cause: The WebSocket (Reverb) connection has been lost.

Fix:

1. Refresh the page — this will reconnect to the WebSocket
2. Check your browser’s network tab for WebSocket errors
3. Verify the Reverb service is running (for self-hosted deployments)

Server Shows as “Degraded”

Symptom: Server status is yellow “Degraded”

Cause: tick_rate dropped below the normal threshold (~15 tick/s).

Meaning: The server is responding but running slowly. Your factory may be too complex for the current VPS specs.

Options:

• Reduce factory complexity (merge/simplify production lines)
• Upgrade to a VPS with more CPU cores
• Enable underclocking on machines to reduce simulation load

Power Panel Shows No Data

Symptom: Power panel is empty but other panels work

Cause: Your factory has no active power circuits (no generators placed yet), or you’re very early in the game with no electrical infrastructure.

This is normal for early-game sessions. The panel populates once you place generators and connect machines to a power grid.

Docker Issues

Server Stopped After Restart

Symptom: Server container stops after system reboot

Cause: The container wasn’t started with --restart unless-stopped.

Fix:

1
2
3
4
5
6
7
8
# Stop and remove the old container
docker stop satisfactory-server && docker rm satisfactory-server

# Recreate with restart policy
docker run -d \
  --name satisfactory-server \
  --restart unless-stopped \
  [... rest of your docker run command ...]

Or if using Compose, Docker Compose services restart automatically if restart: unless-stopped is set (which it is in the guide’s example).

Container Exits Immediately

Symptom: docker ps shows the container stopped

Cause: Usually an error during startup (permissions, missing files, etc.)

Fix: Check logs immediately after the container exits:

1
docker logs satisfactory-server

Look for errors like permission denied (PUID/PGID mismatch) or SteamCMD failures.

Do I need the FRM mod to use FICSIT.monitor?

The FRM mod is required for most monitoring panels. Without FRM, FICSIT.monitor can only show:

• Server status (online/offline/degraded)
• Tick rate
• Player count
• Tech tier and game phase

All other panels (power grid, production, players with positions, trains, drones, factory buildings) require FRM installed and running.

→ See Installing FRM

What version of Satisfactory does the dedicated server require?

Satisfactory 1.0 or later. FICSIT.monitor uses the HTTPS API introduced in 1.0. Experimental branch support depends on Coffee Stain Studios maintaining API compatibility between releases.

Can I run FICSIT.monitor on a Windows machine instead of Ubuntu?

The documentation targets Ubuntu. Docker is available for Windows, so technically you could run the wolveix/satisfactory-server image on Windows using Docker Desktop, but this is not tested or supported.

For VPS hosting, Ubuntu 22.04 or 24.04 LTS is strongly recommended.

Does FICSIT.monitor store my admin password?

Yes, encrypted (Laravel encryption using the APP_KEY). The password is used to re-authenticate when the API token expires. It is never exposed via the API or any dashboard interface.

Ports

What ports do I need to open?

All four must be open for full FICSIT.monitor functionality.

Should I open ports 15000 or 15777?

No. These ports were used in Satisfactory early access and are deprecated since Patch 1.0. Do not open them.

Can I use port forwarding (NAT)?

No. The Satisfactory dedicated server binds to its external IP address. The external port must equal the internal port. NAT-based port forwarding is not supported.

I’m on a home server — can I use FICSIT.monitor?

Yes, if your ISP provides a public IP and you can open the required ports. However, most residential ISPs assign dynamic IPs — you would need a dynamic DNS service (like DuckDNS or No-IP) and update FICSIT.monitor when your IP changes.

FICSIT.monitor

Why does the dashboard show “Server Offline”?

FICSIT.monitor could not reach your server at host:7777. Check:

1. The server container is running: docker ps | grep satisfactory
2. Port 7777 TCP is open in your firewall
3. The IP address in FICSIT.monitor is the public IP (not localhost or 127.0.0.1)

→ See Diagnosing Connection Issues

FRM data is not showing in the dashboard

If server status shows online but all FRM panels show no data:

1. Verify FRM is installed: curl http://YOUR_IP:8080/getPower
2. If connection refused: port 8080 is blocked — open it in your firewall
3. If FRM responds but data is empty: the mod may need a restart (restart the game server container: docker restart satisfactory-server)

What does the 422 error mean when adding a server?

InvalidAdminPasswordException — the admin password you entered is incorrect. Verify the password you set in the game’s Server Settings → Administration tab.

What does the 502 error mean when adding a server?

ServerUnreachableException — FICSIT.monitor’s servers cannot connect to your server at the specified host and port. Check:

1. Port 7777 TCP is open externally
2. The host IP is the public IP, not a private/local IP
3. The server container is actually running

How often are metrics updated?

On the Free plan, all metrics are polled every 30 seconds instead.

How many servers can I monitor?

How long is metric history retained?

Server Performance

What is the minimum VPS spec?

• 4 vCPU (8 recommended)
• 12 GB RAM (16 recommended)
• 20 GB disk (75 recommended)
• Ubuntu 22.04 or 24.04 LTS

The game server consumes more RAM as your factory grows. Monitor RAM usage with docker stats satisfactory-server and upgrade your VPS before you hit the limit.

Why is the server showing “Degraded” status?

Degraded means the tick rate is below the normal threshold (~15 tick/s or lower). Common causes:

• Factory is too large for the server’s CPU
• The VPS is under-provisioned for the current factory size
• A specific game mechanic (fluid simulation, large train networks) is CPU-intensive

Solutions: reduce factory complexity, upgrade to a more powerful VPS, or split the factory across multiple sessions.

The server crashed and won’t restart

Check the Docker logs: docker logs satisfactory-server --tail 50

Common causes:

• Out of RAM — upgrade the VPS
• Corrupted save file — restore from backup in ./data/saves/
• Docker stopped — docker start satisfactory-server

FICSIT.monitor offers five subscription tiers designed to fit different server sizes and monitoring needs — from a single personal server to enterprise-scale deployments.

Plan Comparison

Prices shown exclude IVA/VAT where applicable. Indicative pricing during beta.

Free

0€/month — No credit card required.

• 1 server
• 24 hours of metric history
• 30-second polling interval
• Server status, power, production, players, trains, drones panels
• No alerts, no API access, no historical charts beyond 24h

Best for: trying FICSIT.monitor or monitoring a single personal server where 24-hour history is sufficient.

Hobby

6€/month (58€/year — ~20% off)

Everything in Free, plus:

• 2 servers
• 7 days of metric history
• 15-second polling interval (double the frequency of Free)
• Discord alert notifications

Best for: small groups of friends wanting recent history and basic Discord notifications.

Pro

19€/month (182€/year — ~20% off)

Everything in Hobby, plus:

• 5 servers
• 30 days of metric history
• 10-second polling interval
• Multi-channel alerts (Discord + additional channels)
• Public REST API access (10,000 requests/day)
• Shareable dashboard links — share a read-only dashboard view with others
• Twitch/YouTube overlay widget
• Email support (response within 24 hours)

Best for: active server admins, content creators, and small community servers who want historical charts, API integrations, and sharing capabilities.

Team

49€/month (470€/year — ~20% off)

Everything in Pro, plus:

• 15 servers
• 90 days of metric history
• Multi-user access with roles — Admin, Operator, Viewer
• Optional SSO integration
• 99.9% uptime SLA
• Priority support

Best for: gaming communities, clans, or organizations running multiple servers and needing team-based access control.

Enterprise

Custom pricing — contact us.

Everything in Team, plus:

• Unlimited servers
• Custom data retention period
• On-premises or private Kubernetes deployment option
• 99.99% uptime SLA
• Dedicated support channel
• Custom security audit and compliance review
• Custom API rate limits

Best for: large communities, server hosting providers, or organizations with specific compliance or infrastructure requirements.

Annual Billing

Annual plans provide approximately 20% discount (equivalent to 2 free months):

Frequently Asked Questions

What happens to my data if I downgrade? Data collected while on a higher tier is retained until it expires under your new tier’s retention period. No data is deleted immediately on downgrade.

Can I add more servers beyond my plan limit? No — you must upgrade to a higher tier to add more servers.

Is there a free trial for paid plans? Contact us for trial access to Pro or Team plans.

What counts as a “server”? Each unique Satisfactory dedicated server IP + port combination counts as one server. Multiple instances on different ports of the same machine count as separate servers.

Getting Started

Sign up for free at satisfactory-dashboard.pablohgdev.com. No credit card required for the Free plan.

The Metrics API provides access to all real-time data FICSIT.monitor collects from your Satisfactory server. All endpoints require authentication and a valid server UUID.

Base path: /api/v1/servers/{server_id}/

Replace {server_id} with the UUID from GET /api/v1/servers.

GET /metrics/latest

Latest server state (health, player count, game phase).

Updates every 10 seconds.

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/metrics/latest \
  -H "Authorization: Bearer YOUR_TOKEN"

Response:

1
2
3
4
5
6
7
8
9
10
{
  "time": "2026-04-15T12:00:00Z",
  "tick_rate": 30.1,
  "player_count": 3,
  "tech_tier": 4,
  "game_phase": "PhaseTwo",
  "is_running": true,
  "is_paused": false,
  "total_duration": 86400
}

GET /players

All players and their current status.

Updates every 15 seconds (FRM required).

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/players \
  -H "Authorization: Bearer YOUR_TOKEN"

Response:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[
  {
    "id": "uuid",
    "name": "PlayerName",
    "is_online": true,
    "health": 0.85,
    "speed": 45.2,
    "is_dead": false,
    "pos_x": 12450.5,
    "pos_y": -34200.0,
    "pos_z": 105.3,
    "last_seen_at": "2026-04-15T12:00:00Z"
  }
]

See Players & Sessions Panel for field descriptions.

GET /power/latest

Latest power circuit data.

Updates every 15 seconds (FRM required).

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/power/latest \
  -H "Authorization: Bearer YOUR_TOKEN"

Response:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[
  {
    "circuit_group_id": 1,
    "power_production": 500.0,
    "power_consumed": 420.5,
    "power_capacity": 600.0,
    "power_max_consumed": 650.0,
    "battery_percent": 100.0,
    "battery_capacity": 200.0,
    "battery_differential": 79.5,
    "fuse_triggered": false,
    "time": "2026-04-15T12:00:00Z"
  }
]

See Power Grid Panel for field descriptions.

GET /production/latest

Latest production and consumption rates per item.

Updates every 30 seconds (FRM required).

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/production/latest \
  -H "Authorization: Bearer YOUR_TOKEN"

Response:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[
  {
    "item_class_name": "Desc_IronIngot_C",
    "item_name": "Iron Ingot",
    "item_type": "item",
    "current_prod": 900.0,
    "max_prod": 900.0,
    "current_consumed": 720.0,
    "max_consumed": 900.0,
    "prod_percent": 100.0,
    "cons_percent": 80.0,
    "time": "2026-04-15T12:00:00Z"
  }
]

See Production Panel for field descriptions.

GET /trains

All trains and their current state.

Updates every 30 seconds (FRM required).

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/trains \
  -H "Authorization: Bearer YOUR_TOKEN"

Response:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[
  {
    "id": "uuid",
    "frm_id": "Train_1",
    "name": "Iron Express",
    "status": "SelfDriving",
    "forward_speed": 120.5,
    "payload_mass": 32000.0,
    "max_payload_mass": 48000.0,
    "is_derailed": false,
    "is_pending_derail": false,
    "current_station": "Iron Mine Station",
    "self_driving": true,
    "power_consumed": 25.0,
    "updated_at": "2026-04-15T12:00:00Z"
  }
]

See Trains & Drone Stations Panel.

GET /drones

All drone stations.

Updates every 30 seconds (FRM required).

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/drones \
  -H "Authorization: Bearer YOUR_TOKEN"

Response:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[
  {
    "id": "uuid",
    "frm_id": "DroneStation_1",
    "name": "North Outpost",
    "drone_status": "Flying",
    "paired_station": "Main Hub",
    "avg_round_trip_secs": 45.0,
    "avg_inc_rate": 60.0,
    "avg_out_rate": 60.0,
    "power_consumed": 150.0,
    "updated_at": "2026-04-15T12:00:00Z"
  }
]

See Trains & Drone Stations Panel.

GET /generators

Power generator data cached from FRM.

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/generators \
  -H "Authorization: Bearer YOUR_TOKEN"

Returns the raw generator data from FRM getGenerators, cached in Redis.

GET /extractors

Resource extractor data cached from FRM.

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/extractors \
  -H "Authorization: Bearer YOUR_TOKEN"

Returns the raw extractor data from FRM getExtractor (singular — FRM endpoint name), cached in Redis.

GET /world-inventory

Global world inventory cached from FRM.

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/world-inventory \
  -H "Authorization: Bearer YOUR_TOKEN"

Returns the raw world inventory from FRM getWorldInv, cached in Redis.

GET /resource-sink

AWESOME Sink data cached from FRM.

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/resource-sink \
  -H "Authorization: Bearer YOUR_TOKEN"

Returns the raw resource sink data from FRM getResourceSink, cached in Redis.

GET /dashboard

Full metrics snapshot — all panels in one request. Useful for initial page load or building a complete monitoring view.

1
2
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/{id}/dashboard \
  -H "Authorization: Bearer YOUR_TOKEN"

Returns the combined data from all metric endpoints in a single response object.

Notes

• Endpoints returning cached data (generators, extractors, world-inventory, resource-sink) reflect the last poll cycle (every 15–60 seconds depending on the endpoint)
• All timestamps are ISO 8601 UTC
• Server UUID must belong to the authenticated user — otherwise 404 Not Found

The Servers API provides CRUD operations for managing your Satisfactory server connections in FICSIT.monitor. All endpoints require authentication.

Base path: /api/v1/servers

Server Object

The API returns servers in this format:

1
2
3
4
5
6
7
8
9
10
{
  "id": "uuid",
  "name": "My Factory Server",
  "host": "46.224.182.211",
  "api_port": 7777,
  "frm_http_port": 8080,
  "status": "online",
  "last_seen_at": "2026-04-15T12:00:00Z",
  "created_at": "2026-04-01T00:00:00Z"
}

frm_ws_port and api_token are not included in the response.

GET /api/v1/servers

List all servers belonging to the authenticated user.

1
2
3
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Accept: application/json"

Response (200):

1
2
3
4
5
6
7
8
9
10
11
12
[
  {
    "id": "550e8400-e29b-41d4-a716-446655440000",
    "name": "Production Server",
    "host": "46.224.182.211",
    "api_port": 7777,
    "frm_http_port": 8080,
    "status": "online",
    "last_seen_at": "2026-04-15T12:00:00Z",
    "created_at": "2026-04-01T00:00:00Z"
  }
]

POST /api/v1/servers

Add a new Satisfactory server to FICSIT.monitor. This triggers the onboarding sequence: connectivity check, authentication, and initial metrics fetch.

Request body:

1
2
3
4
5
6
7
8
{
  "name": "My Factory Server",
  "host": "YOUR_SERVER_IP",
  "api_port": 7777,
  "frm_http_port": 8080,
  "frm_ws_port": 8081,
  "admin_password": "YourAdminPassword"
}

1
2
3
4
5
6
7
8
9
10
11
12
curl -X POST https://satisfactory-dashboard.pablohgdev.com/api/v1/servers \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "name": "My Factory Server",
    "host": "YOUR_SERVER_IP",
    "api_port": 7777,
    "frm_http_port": 8080,
    "frm_ws_port": 8081,
    "admin_password": "YourAdminPassword"
  }'

Success response (201):

1
2
3
4
5
6
7
8
9
10
{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "name": "My Factory Server",
  "host": "YOUR_SERVER_IP",
  "api_port": 7777,
  "frm_http_port": 8080,
  "status": "online",
  "last_seen_at": "2026-04-15T12:00:00Z",
  "created_at": "2026-04-15T12:00:00Z"
}

Onboarding Error Codes

GET /api/v1/servers/{id}

Get details for a specific server.

1
2
3
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/SERVER_UUID \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Accept: application/json"

Response (200): Single server object (same format as the list).

Not found (404): Server does not exist or belongs to another user.

PUT /api/v1/servers/{id}

Update server settings. Only the fields you provide are updated.

1
2
3
4
5
6
7
8
curl -X PUT https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/SERVER_UUID \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "name": "Updated Server Name",
    "admin_password": "NewPassword"
  }'

Response (200): Updated server object.

DELETE /api/v1/servers/{id}

Remove a server from FICSIT.monitor. This stops polling for the server and removes it from your dashboard. Historical metric data is retained for your plan’s retention period.

1
2
3
curl -X DELETE https://satisfactory-dashboard.pablohgdev.com/api/v1/servers/SERVER_UUID \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Accept: application/json"

Response (204): Empty body.

Finding Your Server UUID

Your server’s UUID is returned when you add it and in the GET /api/v1/servers list. It is also visible in the dashboard URL: /servers/{uuid}/dashboard.

FICSIT.monitor uses Laravel Sanctum for API authentication. The API supports session-based authentication (cookie) for the web SPA and token-based authentication for external API clients.

Authentication Endpoints

POST /api/register

Create a new user account.

Request:

1
2
3
4
5
6
7
8
9
curl -X POST https://satisfactory-dashboard.pablohgdev.com/api/register \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "name": "Pablo",
    "email": "pablo@example.com",
    "password": "your_secure_password",
    "password_confirmation": "your_secure_password"
  }'

Success response (201):

1
2
3
4
5
{
  "id": "uuid",
  "name": "Pablo",
  "email": "pablo@example.com"
}

Validation error (422):

1
2
3
4
5
6
{
  "message": "The given data was invalid.",
  "errors": {
    "email": ["The email has already been taken."]
  }
}

POST /api/login

Authenticate with email and password. Returns a session cookie.

Request:

1
2
3
4
5
6
7
8
curl -X POST https://satisfactory-dashboard.pablohgdev.com/api/login \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -c cookies.txt \
  -d '{
    "email": "pablo@example.com",
    "password": "your_secure_password"
  }'

Success response (200):

1
2
3
4
5
{
  "id": "uuid",
  "name": "Pablo",
  "email": "pablo@example.com"
}

The session cookie is stored in cookies.txt with -c cookies.txt. Use -b cookies.txt in subsequent requests to authenticate.

Authentication failure (401):

1
2
3
{
  "message": "These credentials do not match our records."
}

POST /api/logout

Invalidate the current session. Requires authentication.

Request:

1
2
3
curl -X POST https://satisfactory-dashboard.pablohgdev.com/api/logout \
  -H "Accept: application/json" \
  -b cookies.txt

Success response (204): Empty body.

GET /api/user

Get the currently authenticated user. Requires authentication.

Request:

1
2
3
curl https://satisfactory-dashboard.pablohgdev.com/api/user \
  -H "Accept: application/json" \
  -b cookies.txt

Success response (200):

1
2
3
4
5
{
  "id": "uuid",
  "name": "Pablo",
  "email": "pablo@example.com"
}

Using the Session for API Requests

After login, include the session cookie in all authenticated requests:

1
2
3
4
5
6
7
8
9
10
11
# Login and save cookie
curl -X POST https://satisfactory-dashboard.pablohgdev.com/api/login \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -c cookies.txt \
  -d '{"email":"pablo@example.com","password":"your_password"}'

# Use the session for subsequent requests
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers \
  -H "Accept: application/json" \
  -b cookies.txt

CSRF Protection

For browser-based clients making state-changing requests (POST, PUT, DELETE), a CSRF token is required. The SPA dashboard handles this automatically. External API clients using session cookies should fetch the CSRF token from /sanctum/csrf-cookie before making state-changing requests.

For scripts and tools, using session cookies with the Accept: application/json header bypasses CSRF requirements on JSON API endpoints.

Unauthenticated Response

Any request to a protected endpoint without authentication returns:

1
2
3
{
  "message": "Unauthenticated."
}

HTTP status: 401 Unauthorized

See Also

• REST API Overview — base URL and general usage
• Servers API — manage your servers
• Metrics API — query server metrics

FICSIT.monitor exposes a REST API for programmatic access to server metrics, player data, and server management. The API uses Sanctum for authentication (Personal Access Tokens or session cookies).

Base URL

1
https://satisfactory-dashboard.pablohgdev.com/api

All endpoints described in this documentation are relative to this base URL.

Authentication

The API supports two authentication methods:

Personal Access Tokens (PATs)

Include the token in the Authorization header:

1
2
3
curl https://satisfactory-dashboard.pablohgdev.com/api/v1/servers \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Accept: application/json"

Session Cookie (SPA)

Used by the web dashboard. The cookie is set when you log in via POST /api/login. Not suitable for external API clients.

Content Type

All requests with a body must include:

1
Content-Type: application/json

All responses are JSON with Content-Type: application/json.

Rate Limiting

Rate limit responses return HTTP 429 Too Many Requests:

1
2
3
{
  "message": "Too Many Attempts."
}

Response Format

Success

Successful responses return the resource directly:

1
2
3
4
5
6
7
8
9
10
{
  "id": "uuid",
  "name": "My Server",
  "host": "46.224.182.211",
  "api_port": 7777,
  "frm_http_port": 8080,
  "status": "online",
  "last_seen_at": "2026-04-15T12:00:00Z",
  "created_at": "2026-04-01T00:00:00Z"
}

List endpoints return arrays (pagination may apply).

Errors

Errors return a standard format:

1
2
3
4
5
6
{
  "message": "Human-readable error message",
  "errors": {
    "field_name": ["Specific validation error"]
  }
}

HTTP Status Codes

Endpoint Overview

Authentication

Configuration

Servers

Server Metrics

CORS

The API allows requests from the dashboard’s own domain. For external API clients, requests must include the Accept: application/json header to receive JSON error responses instead of HTML redirects.

See Also

• API Authentication — PAT creation and usage
• Servers API — server management endpoints
• Metrics API — all metric endpoints with field definitions

FICSIT.monitor is a Laravel 12 application. All configuration is done through environment variables, either in a .env file for local development or Kubernetes Secrets/ConfigMaps for production.

Never commit your .env file or Kubernetes Secrets to a public repository. The .env.example file provides a safe template with no real values.

Application Settings

Database (PostgreSQL + TimescaleDB)

TimescaleDB must be installed and enabled in PostgreSQL. The migrations run CREATE EXTENSION timescaledb; and create hypertables for time-series data.

Redis

Redis is used for: queue backing (Horizon), session storage, and current-state metric cache.

Session & Queue

WebSocket (Laravel Reverb)

Frontend variables (used by Vite to build the React frontend):

VITE_REVERB_HOST should be your public domain, not the internal service name. Clients connect to it from their browsers.

Satisfactory Server Connection

These variables configure how FICSIT.monitor connects to your Satisfactory server. In production, these are set dynamically per-server via the database. The env vars below are for a single default server in development/testing scenarios.

In Kubernetes, SATISFACTORY_FRM_HOST can be the internal ClusterIP service name satisfactory-frm.satisfactory.svc.cluster.local when the dashboard and game server are in the same cluster, avoiding external network traffic.

Mail (Optional)

Mail is used for account-related emails. In development, MAIL_MAILER=log writes emails to the application log instead of sending them.

Minimum Production .env

A minimal working production configuration:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
APP_NAME="FICSIT.monitor"
APP_ENV=production
APP_KEY=base64:GENERATE_THIS_WITH_ARTISAN
APP_DEBUG=false
APP_URL=https://your-domain.com

DB_CONNECTION=pgsql
DB_HOST=postgres
DB_PORT=5432
DB_DATABASE=satisfactory_dashboard
DB_USERNAME=satisfactory
DB_PASSWORD=STRONG_PASSWORD

REDIS_CLIENT=phpredis
REDIS_HOST=redis
REDIS_PORT=6379

SESSION_DRIVER=redis
QUEUE_CONNECTION=redis
BROADCAST_CONNECTION=reverb
CACHE_STORE=redis

REVERB_APP_ID=satisfactory-dashboard
REVERB_APP_KEY=YOUR_REVERB_KEY
REVERB_APP_SECRET=YOUR_REVERB_SECRET
REVERB_HOST=reverb
REVERB_PORT=8080
REVERB_SCHEME=http

VITE_REVERB_APP_KEY=YOUR_REVERB_KEY
VITE_REVERB_HOST=your-domain.com
VITE_REVERB_PORT=443
VITE_REVERB_SCHEME=https

This guide describes the production Kubernetes deployment powering FICSIT.monitor. It deploys two namespaces: satisfactory for the game server, and satisfactory-dashboard for the monitoring application stack.

This is an advanced guide targeting teams with Kubernetes experience. For a simpler setup, use the Docker deployment guide.

Prerequisites

A bare-metal or cloud Kubernetes cluster with:

• MetalLB — bare-metal load balancer (for assigning external IPs)
• Longhorn — distributed block storage (for persistent volumes)
• Traefik — ingress controller
• cert-manager — TLS certificate management (Let’s Encrypt)
• Keel — automated image update deployment

Namespace Structure

1
2
# satisfactory namespace — game server
# satisfactory-dashboard namespace — monitoring app

Game Server Deployment (namespace: satisfactory)

StatefulSet

The game server runs as a StatefulSet with 1 replica:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: satisfactory
  namespace: satisfactory
  annotations:
    keel.sh/policy: force
    keel.sh/trigger: poll
    keel.sh/pollSchedule: "@every 6h"
spec:
  serviceName: satisfactory
  replicas: 1
  template:
    spec:
      containers:
        - name: satisfactory
          image: wolveix/satisfactory-server:latest
          env:
            - name: MAXPLAYERS
              value: "8"
            - name: PGID
              value: "1000"
            - name: PUID
              value: "1000"
            - name: STEAMBETA
              value: "false"
            - name: SKIPUPDATE
              value: "false"
            - name: AUTOSAVEINTERVAL
              value: "300"
          ports:
            - name: game-tcp
              containerPort: 7777
              protocol: TCP
            - name: game-udp
              containerPort: 7777
              protocol: UDP
            - name: reliable
              containerPort: 8888
              protocol: TCP
            - name: frm-http
              containerPort: 8080
              protocol: TCP
            - name: frm-ws
              containerPort: 8081
              protocol: TCP
          resources:
            requests:
              cpu: "2"
              memory: 8Gi
            limits:
              cpu: "4"
              memory: 16Gi
          volumeMounts:
            - name: gamedata
              mountPath: /config
  volumeClaimTemplates:
    - metadata:
        name: gamedata
      spec:
        accessModes:
          - ReadWriteOnce
        storageClassName: longhorn-gameserver
        resources:
          requests:
            storage: 75Gi

Services

satisfactory-tcp (LoadBalancer — external game + API access):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
apiVersion: v1
kind: Service
metadata:
  name: satisfactory-tcp
  namespace: satisfactory
  annotations:
    metallb.universe.tf/allow-shared-ip: "shared-external-ip"
spec:
  type: LoadBalancer
  loadBalancerIP: "YOUR_PUBLIC_IP"
  selector:
    app.kubernetes.io/name: satisfactory
  ports:
    - name: game-tcp
      protocol: TCP
      port: 7777
      targetPort: 7777
    - name: reliable
      protocol: TCP
      port: 8888
      targetPort: 8888

satisfactory-udp (LoadBalancer — game UDP traffic):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
apiVersion: v1
kind: Service
metadata:
  name: satisfactory-udp
  namespace: satisfactory
  annotations:
    metallb.universe.tf/allow-shared-ip: "shared-external-ip"
spec:
  type: LoadBalancer
  loadBalancerIP: "YOUR_PUBLIC_IP"
  selector:
    app.kubernetes.io/name: satisfactory
  ports:
    - name: game-udp
      protocol: UDP
      port: 7777
      targetPort: 7777

satisfactory-frm (ClusterIP — internal FRM access from dashboard):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
apiVersion: v1
kind: Service
metadata:
  name: satisfactory-frm
  namespace: satisfactory
spec:
  type: ClusterIP
  selector:
    app.kubernetes.io/name: satisfactory
  ports:
    - name: frm-http
      protocol: TCP
      port: 8080
      targetPort: 8080
    - name: frm-ws
      protocol: TCP
      port: 8081
      targetPort: 8081

With Kubernetes, FRM (ports 8080/8081) is accessible internally via ClusterIP. You only need to open 8080/8081 on the host firewall if you want external FRM access.

Dashboard Stack (namespace: satisfactory-dashboard)

Components

Web Pod Init Container

The web pod runs an init container that migrates and seeds the database on startup:

1
2
3
4
initContainers:
  - name: init-migrate
    image: ocholoko888/satisfactory-dashboard:latest
    command: ["sh", "-c", "php artisan migrate --force && php artisan db:seed --class=ServerSeeder --force"]

Web Pod Resources

1
2
3
4
5
6
7
resources:
  requests:
    cpu: 250m
    memory: 256Mi
  limits:
    cpu: "1"
    memory: 512Mi

Traefik Ingress with TLS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: dashboard-ingress
  namespace: satisfactory-dashboard
  annotations:
    cert-manager.io/cluster-issuer: cloudflare-clusterissuer
    traefik.ingress.kubernetes.io/router.entrypoints: websecure
spec:
  tls:
    - hosts:
        - satisfactory-dashboard.yourdomain.com
      secretName: dashboard-tls
  rules:
    - host: satisfactory-dashboard.yourdomain.com
      http:
        paths:
          # WebSocket path for Reverb
          - path: /app
            pathType: Prefix
            backend:
              service:
                name: dashboard-reverb
                port:
                  number: 8080
          # Everything else to the web service
          - path: /
            pathType: Prefix
            backend:
              service:
                name: dashboard-web
                port:
                  number: 80

TimescaleDB Setup

PostgreSQL must have TimescaleDB enabled. The migrations create TimescaleDB hypertables automatically, but the extension must be pre-installed. Apply a PostgreSQL ConfigMap with:

1
shared_preload_libraries: timescaledb

Or use a TimescaleDB Docker image instead of plain postgres:15.

Auto-Update with Keel

Keel polls Docker Hub every 6 hours and automatically deploys new images when a newer latest tag is available:

1
2
3
4
5
annotations:
  keel.sh/policy: force
  keel.sh/trigger: poll
  keel.sh/pollSchedule: "@every 6h"
  keel.sh/approvals: "0"

This means deployments update automatically without manual intervention.

See Also

• Environment Variables Reference — configure the Laravel app
• Running with Docker — simpler Docker-based setup