Skip to content

An open-source, self-hostable PaaS alternative to Vercel, Heroku & Netlify that lets you easily deploy static sites, databases, full-stack applications and 360+ one-click services on your own servers.

fix(api): key unauthenticated rate limits by Cloudflare client IP

Andras Bacsaie7465000b35b
diff --git a/.claude/worktrees/agent-a1f84dd00720572e0 b/.claude/worktrees/agent-a1f84dd00720572e0
new file mode 160000
index 0000000000..ee5e46f947
--- /dev/null
+++ b/.claude/worktrees/agent-a1f84dd00720572e0
@@ -0,0 +1 @@
+Subproject commit ee5e46f94738cda56ad014b25ae2f82ce40eb4c6
diff --git a/app/Providers/RouteServiceProvider.php b/app/Providers/RouteServiceProvider.php
index 633216ea48..24cec00b4c 100644
--- a/app/Providers/RouteServiceProvider.php
+++ b/app/Providers/RouteServiceProvider.php
@@ -46,17 +46,17 @@ class RouteServiceProvider extends ServiceProvider
{
RateLimiter::for('api', function (Request $request) {
if ($request->path() === 'api/health') {
- return Limit::perMinute(1000)->by($request->user()?->id ?: $request->ip());
+ return Limit::perMinute(1000)->by($request->user()?->id ?: auth_rate_limit_ip($request));
}
- return Limit::perMinute((int) config('api.rate_limit'))->by($request->user()?->id ?: $request->ip());
+ return Limit::perMinute((int) config('api.rate_limit'))->by($request->user()?->id ?: auth_rate_limit_ip($request));
});
RateLimiter::for('5', function (Request $request) {
- return Limit::perMinute(5)->by($request->user()?->id ?: $request->ip());
+ return Limit::perMinute(5)->by($request->user()?->id ?: auth_rate_limit_ip($request));
});
RateLimiter::for('feedback', function (Request $request) {
- return Limit::perMinute(3)->by($request->user()?->id ?: $request->ip());
+ return Limit::perMinute(3)->by($request->user()?->id ?: auth_rate_limit_ip($request));
});
RateLimiter::for('login', function (Request $request) {
diff --git a/other/nightly/versions.json b/other/nightly/versions.json
index 7262de886a..34821f8761 100644
--- a/other/nightly/versions.json
+++ b/other/nightly/versions.json
@@ -1,7 +1,7 @@
{
"coolify": {
"v4": {
- "version": "4.4"
+ "version": "sha-1e9add3"
},
"nightly": {
"version": "4.5-rc.1"
diff --git a/scripts/restore-backup-vm.sh b/scripts/restore-backup-vm.sh
new file mode 100755
index 0000000000..8c52c4834f
--- /dev/null
+++ b/scripts/restore-backup-vm.sh
@@ -0,0 +1,356 @@
+#!/usr/bin/env bash
+# Restore a Coolify instance backup into an offline KVM VM to test database migrations.
+#
+# Usage:
+# scripts/restore-backup-vm.sh asks for the inputs below
+# scripts/restore-backup-vm.sh destroy deletes the VM, its disk, and the Coolify base images
+#
+# Inputs (asked interactively, so they do not go into the shell history):
+# Backup file pg_dump custom-format backup (.dmp), optionally gzipped (.gz)
+# APP_KEY APP_KEY of the instance that created the backup (base64:...), not shown
+# Version Coolify version or image tag, e.g. 4.3.23 or sha-99c8409 (empty: latest stable)
+#
+# Flow:
+# 1. Base image (once per version, until destroy): a separate builder VM with internet access installs
+# Coolify. It never receives the backup. Its disk is kept as the base image.
+# 2. The restore VM boots from a copy of the base image on a host-only network without
+# internet access and without DNS. It never has internet access, so the restored
+# instance cannot reach real servers, notification channels, or Stripe.
+# 3. The script confirms that the VM is offline, copies the backup, replaces the database,
+# sets APP_KEY, turns off Horizon and the scheduler, and starts Coolify.
+# Coolify runs its migrations and seeders on start; no queued or scheduled job runs.
+#
+# Environment overrides:
+# VM_NAME (coolify-restore-test), VM_MEMORY (4096), VM_VCPUS (4), VM_DISK_SIZE (60G),
+# IMAGE_DIR (/var/lib/libvirt/images/coolify-restore-test),
+# NAT_NETWORK (default), OFFLINE_NETWORK (coolify-restore-offline),
+# OFFLINE_SUBNET (192.168.241)
+
+set -euo pipefail
+
+VM_NAME=${VM_NAME:-coolify-restore-test}
+BUILDER_NAME=$VM_NAME-builder
+VM_MEMORY=${VM_MEMORY:-4096}
+VM_VCPUS=${VM_VCPUS:-4}
+VM_DISK_SIZE=${VM_DISK_SIZE:-60G}
+IMAGE_DIR=${IMAGE_DIR:-/var/lib/libvirt/images/coolify-restore-test}
+NAT_NETWORK=${NAT_NETWORK:-default}
+OFFLINE_NETWORK=${OFFLINE_NETWORK:-coolify-restore-offline}
+OFFLINE_SUBNET=${OFFLINE_SUBNET:-192.168.241}
+# Both VMs use the same MAC address: the guest network config matches the NIC by MAC.
+VM_MAC=52:54:00:c0:1f:01
+UBUNTU_IMAGE_URL=https://cloud-images.ubuntu.com/noble/current/noble-server-cloudimg-amd64.img
+UBUNTU_IMAGE="$IMAGE_DIR/ubuntu-noble-amd64.qcow2"
+SSH_KEY="$IMAGE_DIR/ssh_key"
+VIRSH=(virsh --connect qemu:///system)
+SSH_OPTS=(-i "$SSH_KEY" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR -o ConnectTimeout=5)
+
+log() { printf '\n\033[1;34m==> %s\033[0m\n' "$*"; }
+die() {
+ printf '\033[1;31mERROR: %s\033[0m\n' "$*" >&2
+ exit 1
+}
+
+usage() {
+ sed -n '2,11p' "$0" | sed 's/^# \{0,1\}//'
+ exit 1
+}
+
+# delete_vm <name>: stops and deletes a VM with its disk and seed ISO.
+delete_vm() {
+ if "${VIRSH[@]}" dominfo "$1" >/dev/null 2>&1; then
+ "${VIRSH[@]}" destroy "$1" >/dev/null 2>&1 || true
+ "${VIRSH[@]}" undefine "$1" --nvram >/dev/null 2>&1 || "${VIRSH[@]}" undefine "$1" >/dev/null
+ fi
+ rm -f "$IMAGE_DIR/$1.qcow2" "$IMAGE_DIR/$1-seed.iso"
+}
+
+vm_ip() {
+ "${VIRSH[@]}" domifaddr "$1" --source lease 2>/dev/null |
+ awk '$3 == "ipv4" { sub(/\/.*/, "", $4); print $4; exit }'
+}
+
+wait_for_ip() {
+ local ip=""
+ for _ in $(seq 1 90); do
+ ip=$(vm_ip "$1")
+ [ -n "$ip" ] && break
+ sleep 2
+ done
+ [ -n "$ip" ] || die "VM $1 did not get an IP address from DHCP."
+ echo "$ip"
+}
+
+# wait_for_ssh <ip>: waits for SSH and for cloud-init to finish.
+wait_for_ssh() {
+ for _ in $(seq 1 90); do
+ if ssh "${SSH_OPTS[@]}" "root@$1" true 2>/dev/null; then
+ ssh "${SSH_OPTS[@]}" "root@$1" 'cloud-init status --wait >/dev/null || true'
+ return 0
+ fi
+ sleep 2
+ done
+ die "SSH to root@$1 does not respond."
+}
+
+vm_ssh() { ssh "${SSH_OPTS[@]}" "root@$VM_IP" "$@"; }
+
+ensure_offline_network() {
+ if ! "${VIRSH[@]}" net-info "$OFFLINE_NETWORK" >/dev/null 2>&1; then
+ log "Creating offline libvirt network $OFFLINE_NETWORK ($OFFLINE_SUBNET.0/24)"
+ local xml
+ xml=$(mktemp)
+ # No <forward> element: libvirt blocks all traffic between this network and other networks.
+ # <dns enable='no'/>: the VM cannot resolve host names through the host either.
+ cat >"$xml" <<EOF
+<network>
+ <name>$OFFLINE_NETWORK</name>
+ <bridge stp='on' delay='0'/>
+ <dns enable='no'/>
+ <ip address='$OFFLINE_SUBNET.1' netmask='255.255.255.0'>
+ <dhcp><range start='$OFFLINE_SUBNET.10' end='$OFFLINE_SUBNET.200'/></dhcp>
+ </ip>
+</network>
+EOF
+ "${VIRSH[@]}" net-define "$xml" >/dev/null
+ rm -f "$xml"
+ "${VIRSH[@]}" net-autostart "$OFFLINE_NETWORK" >/dev/null
+ fi
+ if [[ " $("${VIRSH[@]}" net-list --name | xargs) " != *" $OFFLINE_NETWORK "* ]]; then
+ "${VIRSH[@]}" net-start "$OFFLINE_NETWORK" >/dev/null
+ fi
+}
+
+# create_vm <name> <backing-image> <network>: creates a VM with a copy-on-write disk on the image.
+create_vm() {
+ local name=$1 backing=$2 network=$3 seed_dir
+ log "Creating VM $name on network $network (${VM_VCPUS} vCPU, ${VM_MEMORY} MiB RAM)"
+ qemu-img create -q -f qcow2 -F qcow2 -b "$backing" "$IMAGE_DIR/$name.qcow2" "$VM_DISK_SIZE"
+
+ seed_dir=$(mktemp -d)
+ cat >"$seed_dir/user-data" <<EOF
+#cloud-config
+hostname: $name
+disable_root: false
+ssh_pwauth: false
+users:
+ - name: root
+ ssh_authorized_keys:
+ - $(cat "$SSH_KEY.pub")
+runcmd:
+ - sed -i 's/^#\?PermitRootLogin.*/PermitRootLogin prohibit-password/' /etc/ssh/sshd_config
+ - systemctl restart ssh
+EOF
+ printf 'instance-id: %s-%s\nlocal-hostname: %s\n' "$name" "$(date +%s)" "$name" >"$seed_dir/meta-data"
+ if command -v xorriso >/dev/null; then
+ xorriso -as mkisofs -quiet -V cidata -J -r -o "$IMAGE_DIR/$name-seed.iso" "$seed_dir/user-data" "$seed_dir/meta-data" 2>/dev/null
+ elif command -v cloud-localds >/dev/null; then
+ cloud-localds "$IMAGE_DIR/$name-seed.iso" "$seed_dir/user-data" "$seed_dir/meta-data"
+ else
+ genisoimage -quiet -V cidata -J -r -o "$IMAGE_DIR/$name-seed.iso" "$seed_dir/user-data" "$seed_dir/meta-data"
+ fi
+ rm -rf "$seed_dir"
+
+ virt-install --connect qemu:///system --name "$name" --memory "$VM_MEMORY" --vcpus "$VM_VCPUS" \
+ --import --os-variant ubuntu24.04 \
+ --disk "path=$IMAGE_DIR/$name.qcow2,format=qcow2,bus=virtio" \
+ --disk "path=$IMAGE_DIR/$name-seed.iso,device=cdrom" \
+ --network "network=$network,model=virtio,mac=$VM_MAC" \
+ --graphics none --noautoconsole >/dev/null
+}
+
+# build_base_image <path>: installs Coolify in a builder VM with internet access and keeps its disk.
+build_base_image() {
+ local base=$1
+ if [ ! -f "$UBUNTU_IMAGE" ]; then
+ log "Downloading Ubuntu 24.04 cloud image"
+ curl -fL --progress-bar -o "$UBUNTU_IMAGE.part" "$UBUNTU_IMAGE_URL"
+ mv "$UBUNTU_IMAGE.part" "$UBUNTU_IMAGE"
+ fi
+
+ delete_vm "$BUILDER_NAME"
+ create_vm "$BUILDER_NAME" "$UBUNTU_IMAGE" "$NAT_NETWORK"
+ VM_IP=$(wait_for_ip "$BUILDER_NAME")
+ wait_for_ssh "$VM_IP"
+
+ log "Installing Coolify $VERSION in the builder VM (no backup data in this VM)"
+ vm_ssh "curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash -s -- $VERSION"
+
+ vm_ssh 'shutdown -h now' || true
+ for _ in $(seq 1 60); do
+ [ "$("${VIRSH[@]}" domstate "$BUILDER_NAME")" = "shut off" ] && break
+ sleep 2
+ done
+ [ "$("${VIRSH[@]}" domstate "$BUILDER_NAME")" = "shut off" ] || die "The builder VM did not shut down."
+ "${VIRSH[@]}" undefine "$BUILDER_NAME" --nvram >/dev/null 2>&1 || "${VIRSH[@]}" undefine "$BUILDER_NAME" >/dev/null
+ mv "$IMAGE_DIR/$BUILDER_NAME.qcow2" "$base"
+ rm -f "$IMAGE_DIR/$BUILDER_NAME-seed.iso"
+}
+
+# --- main ---------------------------------------------------------------------
+
+[ "${1:-}" = "destroy" ] && {
+ delete_vm "$VM_NAME"
+ delete_vm "$BUILDER_NAME"
+ rm -f "$IMAGE_DIR"/coolify-base-*.qcow2
+ echo "Deleted VM $VM_NAME, its disk, and the Coolify base images."
+ exit 0
+}
+[ $# -eq 0 ] || usage
+[ -t 0 ] || die "Run this script in an interactive terminal: it asks for its inputs."
+
+read -r -e -p "Backup file (.dmp or .gz): " BACKUP_FILE
+BACKUP_FILE=${BACKUP_FILE/#\~/$HOME}
+read -r -s -p "APP_KEY of the backed-up instance (input is hidden): " APP_KEY
+echo
+read -r -p "Coolify version or image tag (empty for latest stable): " VERSION
+
+[ -s "$BACKUP_FILE" ] || die "Backup file '$BACKUP_FILE' does not exist or is empty."
+[[ "$APP_KEY" == base64:* ]] || die "APP_KEY must start with 'base64:'."
+for cmd in virsh virt-install qemu-img ssh scp ssh-keygen curl jq; do
+ command -v "$cmd" >/dev/null || die "Missing command: $cmd"
+done
+[ -e /dev/kvm ] || die "/dev/kvm is not available."
+
+if [ -z "$VERSION" ]; then
+ VERSION=$(curl -fsSL https://cdn.coollabs.io/coolify/versions.json | jq -r '.coolify.v4.version')
+ echo "Latest stable version: $VERSION"
+fi
+[[ "$VERSION" =~ ^[A-Za-z0-9._-]+$ ]] || die "Version '$VERSION' contains characters that are not allowed."
+BASE_IMAGE="$IMAGE_DIR/coolify-base-$VERSION.qcow2"
+
+# Other VMs and containers can use most of the host memory. A VM that does not fit
+# makes the host swap until it stops responding, so stop before it starts.
+# The previous VM is deleted below, so its memory counts as available.
+OLD_VM_KIB=$("${VIRSH[@]}" dominfo "$VM_NAME" 2>/dev/null | awk '/^State:/ { running = ($2 == "running") } /^Used memory:/ { kib = $3 } END { print running ? kib : 0 }' || true)
+AVAILABLE_MIB=$(($(awk '/^MemAvailable:/ { print $2 }' /proc/meminfo) / 1024 + ${OLD_VM_KIB:-0} / 1024))
+REQUIRED_MIB=$((VM_MEMORY + 2048))
+if [ "$AVAILABLE_MIB" -lt "$REQUIRED_MIB" ]; then
+ die "Not enough free memory: ${AVAILABLE_MIB} MiB available, ${REQUIRED_MIB} MiB required (VM_MEMORY + 2048 MiB for the host).
+Stop other VMs (virsh --connect qemu:///system list) or set a lower VM_MEMORY."
+fi
+
+if "${VIRSH[@]}" dominfo "$VM_NAME" >/dev/null 2>&1; then
+ log "Deleting the previous VM $VM_NAME"
+fi
+delete_vm "$VM_NAME"
+
+mkdir -p "$IMAGE_DIR"
+if [ ! -f "$SSH_KEY" ]; then
+ # The comment must not contain "coolify": install.sh removes such lines from authorized_keys.
+ ssh-keygen -q -t ed25519 -N '' -C restore-test-vm -f "$SSH_KEY"
+fi
+
+if [ -f "$BASE_IMAGE" ]; then
+ log "Using the cached base image for Coolify $VERSION"
+else
+ build_base_image "$BASE_IMAGE"
+fi
+
+ensure_offline_network
+create_vm "$VM_NAME" "$BASE_IMAGE" "$OFFLINE_NETWORK"
+VM_IP=$(wait_for_ip "$VM_NAME")
+log "VM IP address on the offline network: $VM_IP"
+wait_for_ssh "$VM_IP"
+
+log "Confirming that the VM has no internet access"
+if vm_ssh 'timeout 5 bash -c "echo >/dev/tcp/1.1.1.1/443" 2>/dev/null || timeout 5 bash -c "echo >/dev/tcp/8.8.8.8/53" 2>/dev/null'; then
+ die "The VM can reach the internet. Stopped before the backup was copied."
+fi
+if vm_ssh 'getent hosts cdn.coollabs.io >/dev/null'; then
+ die "The VM can resolve internet host names. Stopped before the backup was copied."
+fi
+
+log "Copying the backup into the VM"
+if gzip -t "$BACKUP_FILE" 2>/dev/null; then
+ gzip -dc "$BACKUP_FILE" | vm_ssh 'cat >/root/coolify-backup.dmp'
+else
+ scp "${SSH_OPTS[@]}" "$BACKUP_FILE" "root@$VM_IP:/root/coolify-backup.dmp"
+fi
+
+log "Restoring the backup and starting Coolify (migrations run on start)"
+# Send APP_KEY through stdin, so it does not show in the process list of this host or the VM.
+{
+ printf 'APP_KEY=%q\n' "$APP_KEY"
+ cat <<'REMOTE'
+set -euo pipefail
+cd /data/coolify/source
+
+for _ in $(seq 1 60); do
+ [ "$(docker inspect -f '{{.State.Health.Status}}' coolify-db 2>/dev/null)" = healthy ] && break
+ sleep 2
+done
+
+# Start the same image tag again after the restore.
+LATEST_IMAGE=$(docker inspect -f '{{.Config.Image}}' coolify | sed 's/.*://')
+docker stop coolify coolify-realtime >/dev/null
+
+sed -i "s|^APP_KEY=.*|APP_KEY=${APP_KEY}|" .env
+
+# Turn off Horizon (queue workers) and the scheduler: no job from the backup runs.
+# Jobs that the UI dispatches stay in Redis and are never processed.
+for flag in HORIZON_ENABLED SCHEDULER_ENABLED; do
+ sed -i "/^${flag}=/d" .env
+ echo "${flag}=false" >>.env
+done
+
+# Recreate the database: tables from a newer fresh install must not remain.
+docker exec coolify-db psql -q -U coolify -d postgres -v ON_ERROR_STOP=1 \
+ -c 'DROP DATABASE coolify WITH (FORCE)' -c 'CREATE DATABASE coolify OWNER coolify'
+echo "Running pg_restore..."
+docker exec -i coolify-db pg_restore --exit-on-error --no-acl --no-owner -U coolify -d coolify </root/coolify-backup.dmp
+
+# Drop cached data of the fresh installation.
+REDIS_PASSWORD=$(grep '^REDIS_PASSWORD=' .env | cut -d= -f2-)
+docker exec coolify-redis redis-cli -a "$REDIS_PASSWORD" --no-auth-warning FLUSHALL >/dev/null
+
+COMPOSE_FILES="-f docker-compose.yml -f docker-compose.prod.yml"
+[ -f docker-compose.custom.yml ] && COMPOSE_FILES="$COMPOSE_FILES -f docker-compose.custom.yml"
+[ -f docker-compose.postgres-upgrade.yml ] && COMPOSE_FILES="$COMPOSE_FILES -f docker-compose.postgres-upgrade.yml"
+echo "Starting Coolify $LATEST_IMAGE..."
+# --pull never: the VM is offline, all images come from the base image.
+# shellcheck disable=SC2086
+LATEST_IMAGE=$LATEST_IMAGE docker compose --env-file .env $COMPOSE_FILES up -d --pull never --wait --wait-timeout 600
+
+# The container reports healthy while migrations still run on a large database.
+# Seeders continue in the background; with many servers they can run for a long time.
+echo "Waiting for migrations to finish..."
+while docker exec coolify sh -c "ps aux | grep -q '[a]rtisan start:migration'"; do
+ sleep 5
+done
+
+echo
+echo "--- Migration output (docker logs coolify) ---"
+docker logs coolify 2>&1 | sed -n '/Migration is enabled/,/Seeder is enabled/p'
+echo
+echo "--- Errors after start ---"
+docker logs coolify 2>&1 | grep -iE 'error|exception|fail' | tail -n 30 || true
+echo
+echo "--- Pending migrations ---"
+docker exec coolify php artisan migrate:status --pending || true
+echo
+echo "--- Queue workers and scheduler ---"
+if docker exec coolify sh -c "ps aux | grep -qE '[a]rtisan (horizon|schedule:work|queue:work)'"; then
+ echo "ERROR: A queue worker or the scheduler runs."
+ exit 1
+fi
+echo "Horizon and the scheduler are off."
+REMOTE
+} | vm_ssh 'bash -s'
+
+HOST_ADDR=$(hostname -f 2>/dev/null || hostname)
+cat <<EOF
+
+$(printf '\033[1;32m')Restore finished.$(printf '\033[0m')
+
+ Coolify UI (from this host): http://$VM_IP:8000
+ From your workstation: ssh -N -L 8000:$VM_IP:8000 -L 6001:$VM_IP:6001 -L 6002:$VM_IP:6002 root@$HOST_ADDR
+ then open http://localhost:8000
+ Log in with a user account from the backup.
+
+ SSH into the VM: ssh -i $SSH_KEY root@$VM_IP
+ Coolify logs: ssh -i $SSH_KEY root@$VM_IP docker logs -f coolify
+ Delete the VM: $0 destroy
+
+ The VM never had internet access. Horizon and the scheduler are off, so no job runs.
+EOF
diff --git a/tests/Feature/ApiRateLimitClientIpTest.php b/tests/Feature/ApiRateLimitClientIpTest.php
new file mode 100644
index 0000000000..b2272294e3
--- /dev/null
+++ b/tests/Feature/ApiRateLimitClientIpTest.php
@@ -0,0 +1,56 @@
+<?php
+
+use App\Models\InstanceSettings;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\RateLimiter;
+use Illuminate\Testing\TestResponse;
+
+uses(RefreshDatabase::class);
+
+beforeEach(function () {
+ config()->set('app.maintenance.store', 'array');
+ config()->set('api.rate_limit', 2);
+
+ InstanceSettings::forceCreate(['id' => 0]);
+});
+
+function pushSentinelFrom(string $clientIp): TestResponse
+{
+ return test()
+ ->withHeader('CF-Connecting-IP', $clientIp)
+ ->withServerVariables(['REMOTE_ADDR' => '172.70.0.1'])
+ ->postJson('/api/v1/sentinel/push');
+}
+
+it('gives each Cloudflare client ip its own sentinel push bucket on cloud', function () {
+ config()->set('constants.coolify.self_hosted', false);
+
+ pushSentinelFrom('203.0.113.10')->assertUnauthorized();
+ pushSentinelFrom('203.0.113.10')->assertUnauthorized();
+ pushSentinelFrom('203.0.113.10')->assertStatus(429);
+
+ pushSentinelFrom('203.0.113.20')->assertUnauthorized();
+});
+
+it('ignores the Cloudflare client ip for sentinel pushes on self-hosted instances', function () {
+ config()->set('constants.coolify.self_hosted', true);
+
+ pushSentinelFrom('203.0.113.10')->assertUnauthorized();
+ pushSentinelFrom('203.0.113.10')->assertUnauthorized();
+
+ pushSentinelFrom('203.0.113.20')->assertStatus(429);
+});
+
+it('keys unauthenticated limiters by the Cloudflare client ip on cloud', function (string $limiter) {
+ config()->set('constants.coolify.self_hosted', false);
+
+ $request = Request::create('/', server: [
+ 'REMOTE_ADDR' => '172.70.0.1',
+ 'HTTP_CF_CONNECTING_IP' => '203.0.113.10',
+ ]);
+
+ $limit = RateLimiter::limiter($limiter)($request);
+
+ expect($limit->key)->toBe('203.0.113.10');
+})->with(['api', '5', 'feedback']);