Contabo billing, backup, and cancel

What after-sales means on Contabo

After-sales is where Contabo’s low sticker meets administrative reality: how you pay, how auto-renew works, how cancel deletes data, how backups differ from snapshots, and how to pause AI workloads so a backup is consistent. Contabo publishes help articles for cancel and refunds; this page teaches the operational reading of those articles with verify-on-site discipline.

AiXVPS is not Contabo support. When money or data deletion is at stake, Contabo’s Customer Panel and Contabo help.contabo.com win. We cite patterns Contabo documented as of our research pass; Contabo can change them—re-check before you act.

Contabo after-sales is literal: cancel deletes Contabo-side snapshots/backups with the service. The service renews on its term until you submit cancellation; automatic payment collection is separate, and disabling auto-pay does not cancel the service. AI hosts lose workflow glue if they cancel without portable exports.

This page is ordered the way incidents happen: money first (so the box stays up), then cancel literacy (so you do not surprise-delete), then backup mechanics, then the pause ritual that makes backups trustworthy for automation hosts.

Payment methods and invoices

Contabo’s checkout and Customer Control Panel list methods that typically include major cards, PayPal, and bank transfer options depending on currency and region (as listed on Contabo — re-check). Corporate procurement often prefers bank transfer; freelancers often prefer cards/PayPal. Each method has failure modes: 3-D Secure loops, PayPal holds, SEPA delays. Unpaid renewals risk suspension on Contabo’s timeline—not yours.

Download Contabo invoices from the panel into your accounting folder every month. Contabo VAT treatment depends on your customer profile and location; do not invent tax advice from this page. If Contabo shows reverse charge or VAT-inclusive lines, copy Contabo’s document into your books as Contabo emitted it.

For AI automation shops, tag Contabo invoices by project so API spend and Contabo VPS spend do not blur. Contabo will not tag them for you.

Renewal and auto-renew

Contract renewal and payment collection are separate. Record the renewal period, next charge date, and cancellation deadline shown for your Contabo service. Disabling automatic payment does not submit a cancellation request— Contabo’s help on automatic renewal and refunds still requires an explicit cancel (and, for some refund windows, a support ticket). See Contabo’s auto-renew article and refund article (verify live).

Contabo’s help materials discuss refund windows around automatic renewals for customers outside Germany—on the order of roughly 72 hours after automatic renewal in Contabo’s refund article framing. Contabo’s “Can I get a refund?” article states the automatic-renewal refund option is not available for customers in Germany—verify live. Read Contabo’s own refund help before you assume a cooling-off period exists for your account type: help.contabo.com — search Contabo’s current “refund” / “cancellation” articles and confirm the 72-hour language against your contract.

Practical habit: calendar Contabo renewals against the contractual notice deadline Contabo shows for your product (some terms need more than a week— Contabo’s product/terms pages decide), with margin. Submitting cancel is not the same as the service ending; save the displayed termination date. Fighting a renewal after the fact is always worse than preventing it.

How to cancel in the Customer Panel

Contabo documents cancellation through the Customer Control Panel for the relevant service. The motion is roughly: sign in → find the VPS/service → choose cancel/terminate per Contabo’s UI → confirm destructive warnings. Contabo’s help article on canceling a service is the authoritative click-path; UI labels move, so follow Contabo’s screenshots in help.contabo.com rather than memorizing ours.

Critical Contabo warning Contabo itself emphasizes: when you cancel, snapshots and backups associated with that service are deleted. There is no romantic archive Contabo keeps “just in case” for a canceled VPS. Export first.

Private customers may have a 14-day revocation right Contabo describes for distance contracts—again, confirm Contabo’s current wording and that it applies to your status. Contabo will typically require explicit confirmation that data will be lost. Type carefully.

Help anchors to open ( Contabo may reorganize paths; search if URLs move):

• Contabo help — How do I cancel a service (verify live)
• Contabo help — Can I get a refund (verify live)

Contabo reorganized help onto help.contabo.com/en/support/solutions/articles/… paths. If a linked article moves, use Contabo help search for “cancel service” and “refund”—do not invent policy from memory.

Business accounts and private consumers can see different Contabo legal framings. If you bought Contabo through a company VAT ID, do not assume consumer revocation wording Contabo publishes for private accounts applies. Contabo’s help text is written carefully; read the audience Contabo names in the article.

After you cancel, watch Contabo for residual products: DNS, Object Storage, separate Backup Space, expired domains Contabo might sell, or sibling VPS you forgot. Contabo accounts accumulate clutter; clutter becomes surprise invoices.

Fees, unused time, and refunds

Contabo’s commercial default for ordinary cancel-at-term-end is that you paid for a period and Contabo provided it; pro-rata generosity is not something to assume. Contabo’s refund article is where exceptions (auto-renew window, statutory rights, Contabo goodwill cases) live. Read it cold before you open a ticket demanding money back because you forgot to cancel.

Location fees, license add-ons (Windows), Auto Backup fees, and Object Storage are separate lines. Canceling the VPS may not auto-clean every Contabo product in the account—check Contabo’s panel for leftover billable rows.

Honesty: Contabo’s price board is aggressive; Contabo’s refund posture is correspondingly strict outside documented windows. Plan Contabo exits with exports completed before you click cancel.

Snapshots versus Auto Backup

Neither replaces off-site exports of n8n workflows, Postgres dumps, and model manifests. Contabo protects Contabo disks; you protect portable truth.

Also consider Contabo Object Storage / Backup Space products Contabo sells for file-level copies when VM snapshots are the wrong granularity.

Pause AI and automation before backup or snapshot

A hot snapshot of a busy AI box can capture half-written SQLite files, torn queue states, and model shards mid-update. Contabo will happily snapshot whatever the hypervisor sees; Contabo will not make that consistent for your app. For databases and queues that write continuously, pause (or dump consistently) before you trust a Contabo snapshot or Auto Backup. Idle read-mostly boxes are lower risk—still prefer a dump.

Runbook — pause before Contabo manual snapshot (and before any backup you intend to trust):

1. Announce a maintenance window to humans who use the Contabo endpoint.
2. Stop ingest — hold upstream events durably, deactivate triggers/webhooks and polling sources, and verify new jobs stop landing. Pausing consumers alone does not stop enqueueing.
3. Drain — wait for running executions to finish or fail fast.
4. Stop application writers — stop workers and model servers that write state; keep the database running for the dump.
5. Logical dump — run pg_dump / vendor dump; verify exit status and nonempty file; copy the dump off-server.
6. Optional quiesce — only after a verified dump, stop the database cleanly if you want a quieter disk for a manual Contabo snapshot.
7. Manual Contabo snapshot — trigger from the panel and confirm completion in Contabo before you restart writers.
8. Start services in dependency order; smoke-test; re-enable ingest.

Do not snapshot mid-weight download—finish or pause the pull first. Auto Backup is separate from portable dumps. Contabo controls Auto Backup timing. Auto Backup restore overwrites the same VPS (instance offline during restore)—not a clone-to-staging path. Use portable dumps for staging drills; practice Auto Backup restore only on a disposable VPS with that VPS’s own backup.

For pure API-orchestrator Contabo boxes with little local state, you can sometimes snapshot more casually—but still prefer draining n8n executions so you do not resume half-posted WordPress drafts.

GPU VPS note: if Contabo Auto Backup is unavailable on that SKU, this pause ritual still applies before manual exports and before Contabo snapshots Contabo allows on that product.

For a database too large for logical exports, design a tested physical-backup/WAL recovery process using the database vendor's documentation. A generic “backup mode” instruction is not enough to make a hypervisor snapshot application-consistent.

Do not rely on aligning batch video jobs to Contabo Auto Backup. Contabo controls that window; your runbook should rely on portable dumps you schedule.

Export checklist before cancel

1. n8n workflow JSON + credentials inventory (secrets stored in a vault, not only Contabo).
2. Database dumps and .env samples without live secrets in Git.
3. Model manifests and license notes; weights re-downloaded from upstream if needed.
4. DNS TTL lowered; IP dependencies documented.
5. Object Storage copies of user media.
6. Contabo invoices for accounting.
7. Confirm Contabo cancel UI warnings about snapshot/backup deletion—then cancel.

Support expectations

Contabo support is ticket-based. Contabo’s strength is price density, not dedicated account management. Write Contabo tickets with service ID, IP, region, timeline, and what you already tried. Attach Contabo panel screenshots when Contabo asks. For billing disputes, Contabo’s refund article and your payment provider logs matter more than tone.

Auto Backup schedule coordination

Contabo Auto Backup runs on Contabo’s schedule for the add-on. Your AI jobs run on yours. If they collide, application consistency may require additional coordination. Contabo documents that customers cannot choose Auto Backup execution time. Do not plan production freezes around a guessed clock. Keep independently scheduled, application-consistent exports (dumps + off-site copies). Treat Auto Backup as provider-side disk history on Contabo’s schedule—not as your primary recovery plan.

Test restore on Contabo before you need it. A backup never restored is a rumor. Practice application recovery by restoring portable dumps onto a separate staging VPS. Practice Contabo Auto Backup restore only on a disposable VPS using that VPS’s own backup—restore overwrites the same instance and takes it offline during the operation (verify Contabo Auto Backup docs).

Retention Contabo advertises for Auto Backup is a product parameter—read Contabo’s live add-on page. Do not assume year-long Contabo retention on the cheapest add-on tier. For long retention, push dumps to Contabo Object Storage or another cloud with lifecycle rules you set.

Pause runbook for n8n and Docker (copyable)

This illustrative Bash sequence runs through SSH on the Contabo VPS, using the automation starter's /opt/contabo-ai/compose.yaml and service names n8n, runners, and db. Install Docker Compose v2 and standard GNU tools first. For 1-click or queue-mode deployments, discover your actual paths and map all application writers first: main, webhook processors, queue workers, media jobs, external clients and local model writers. A task runner is not an n8n queue worker. Do not paste a list of service names from another installation.

Manual gate before running: hold durable upstream events, deactivate/unpublish relevant webhook, schedule and polling workflows, then inspect running, queued, waiting and manual executions in the UI. Let active work finish and reconcile waiting/resumable work and external side effects. The deployment checklist explains this gate. Stopping a container is not queue draining, and a database dump alone does not synchronize Redis, external storage and third-party API side effects.

#!/usr/bin/env bash
# Illustrative Contabo pause + logical dump. Adapt before running.
set -euo pipefail
umask 077
cd /opt/contabo-ai
docker compose config --quiet
# Keep this directory outside application-writable paths.
sudo install -d -m 700 -o "$(id -un)" -g "$(id -gn)" /var/backups/contabo
STAMP=$(date -u +%Y%m%dT%H%M%SZ)
# mktemp avoids overwriting a previous dump if two attempts share a minute.
PARTIAL=$(mktemp "/var/backups/contabo/n8n-$STAMP.XXXXXX.sql.partial")
FINAL=${PARTIAL%.partial}
finish() {
  RC=$?
  if test "$RC" -ne 0; then
    rm -f -- "$PARTIAL"
    echo 'FAILED: keep ingress paused. Inspect services and recover deliberately.' >&2
  fi
}
trap finish EXIT
trap 'exit 130' INT
trap 'exit 143' TERM
# After the MANUAL drain gate, stop every application writer.
docker compose stop -t 120 n8n
docker compose stop -t 30 runners
# If your mapped deployment has more writers, stop them before proceeding.
# Inspect exit state: killed/incomplete work needs reconciliation.
docker compose ps --all
# Database remains running. No pipelines may hide pg_dump's exit status.
if ! docker compose exec -T db pg_dump -U n8n -d n8n \
    --no-owner --no-privileges > "$PARTIAL"; then
  echo 'pg_dump failed; no final dump created' >&2
  exit 1
fi
test -s "$PARTIAL" || { echo 'Dump is empty' >&2; exit 1; }
mv -- "$PARTIAL" "$FINAL"
sha256sum -- "$FINAL" > "$FINAL.sha256"
printf 'Dump ready: %s\n' "$FINAL"
# STOP HERE: copy the dump/checksum off-server and test recovery.
# Do not automatically resume just because a dump file exists.

The script stops on failure and does not automatically reopen ingress. The database stays running through pg_dump; its transaction-consistent database view is not proof of whole-system consistency. A nonempty dump plus a checksum detects neither a broken schema nor missing encryption keys. Preserve the matching N8N_ENCRYPTION_KEY, Compose/version pins, n8n persistent files, configuration, and any external artifacts separately through an encrypted, access-controlled export. Do not print .env or export decrypted credentials into shared logs.

Copy off-server before touching the snapshot button

From your trusted workstation with OpenSSH, use the exact dump basename printed above. Verify the SSH fingerprint and adapt host/user; this example writes into a new private local directory. Your workstation's disk should be encrypted, and long-retention copies should use encrypted backup storage with tested retention rules. Copies on another directory of the same VPS are not off-server backups.

# Workstation Bash, not the Contabo SSH shell:
set -euo pipefail
umask 077
DUMP='REPLACE_WITH_EXACT_n8n_TIMESTAMP_RANDOM.sql'
HOST='REPLACE_WITH_VPS_IP'
[[ "$DUMP" =~ ^n8n-[A-Za-z0-9._-]+\.sql$ ]] || exit 1
[[ "$HOST" != REPLACE_WITH_VPS_IP ]] || exit 1
LOCAL=$(mktemp -d "$HOME/contabo-export.XXXXXXXX")
scp -p "ops@$HOST:/var/backups/contabo/$DUMP" \
       "ops@$HOST:/var/backups/contabo/$DUMP.sha256" "$LOCAL/"
# The checksum's original absolute path is not a workstation path.
EXPECTED=$(awk 'NR==1 {print $1}' "$LOCAL/$DUMP.sha256")
[[ "$EXPECTED" =~ ^[a-f0-9]{64}$ ]] || exit 1
printf '%s  %s\n' "$EXPECTED" "$LOCAL/$DUMP" | sha256sum --check -
echo 'Off-server bytes verified; restore drill still required'

For a manual Contabo snapshot, keep writers stopped, optionally stop Postgres cleanly after the successful dump, trigger the snapshot in the panel, and confirm completion before resuming. If a snapshot fails, do not assume it exists: keep the verified export and choose whether to retry the snapshot or recover service under the maintenance plan. Contabo controls Auto Backup timing; this procedure never assumes a guessed backup clock.

Resume only after the recovery gate

Return to the VPS. If you stopped the database, start and verify it first. Keep intake held. Starting n8n may resume waiting executions, so resolve that risk before these commands.

set -euo pipefail
cd /opt/contabo-ai
docker compose up -d --wait --wait-timeout 120 db
docker compose up -d --wait --wait-timeout 180 n8n runners
curl -fsS --max-time 10 http://127.0.0.1:5678/healthz/readiness >/dev/null
# Verify external TLS, login, stored credential decryption, and a harmless
# manual workflow/Code node. Only then re-enable recorded workflows
# and upstream publishers, replaying held event IDs with deduplication.

If resume fails, leave intake paused; inspect redacted logs locally and do not loop restarts or delete volumes. Restore into an isolated replacement if necessary. If a hypervisor failure causes an unclean guest shutdown, provider disk history may still be useful; a separately verified logical export and a practiced restore give you another recovery route. Wrap these steps in your own dated runbook. Contabo's snapshot button does not export your database.

Disposable Postgres restore drill: no production target

Run this on a separate staging host with Docker and Bash—not on your production VPS. Transfer only the trusted dump you just created through a protected channel. Set the absolute dump path and the same reviewed Postgres 17 image tag and digest used by the source. This creates a fresh, uniquely named volume and container, publishes no ports, and gives the database no network. Local trust authentication is used only inside this disposable, network-isolated container; never reuse that setting on a reachable database. Docker administrators can still access its data.

#!/usr/bin/env bash
set -euo pipefail
: "${DUMP_PATH:?Set absolute path to trusted SQL dump on STAGING}"
: "${PG_IMAGE:?Set postgres:17.MINOR@sha256:REVIEWED_DIGEST}"
[[ "$DUMP_PATH" == /* ]] && test -s "$DUMP_PATH"
[[ "$PG_IMAGE" =~ ^postgres:17\.[0-9]+@sha256:[a-f0-9]{64}$ ]] || exit 1
read -r -p 'Type STAGING-ONLY to confirm isolated host: ' ACK
[[ "$ACK" == STAGING-ONLY ]] || exit 1
ID="contabo-restore-$(date -u +%Y%m%dT%H%M%S)-$RANDOM"
VOL="$ID-data"
# Never select an existing volume or container.
if docker volume inspect "$VOL" >/dev/null 2>&1; then exit 1; fi
docker pull "$PG_IMAGE"
docker volume create "$VOL" >/dev/null
docker run -d --name "$ID" --network none --restart=no \
  --memory=2g --cpus=2 \
  -e POSTGRES_HOST_AUTH_METHOD=trust \
  -e POSTGRES_USER=n8n -e POSTGRES_DB=n8n \
  -v "$VOL:/var/lib/postgresql/data" "$PG_IMAGE" >/dev/null
# Leave the volume for deliberate cleanup, including on failure.
trap 'docker stop "$ID" >/dev/null 2>&1 || true' EXIT
READY=0
for TRY in {1..30}; do
  if docker exec "$ID" pg_isready -h 127.0.0.1 -U n8n -d n8n >/dev/null 2>&1; then
    READY=1; break
  fi
  sleep 2
done
test "$READY" -eq 1 || exit 1
if ! docker exec -i "$ID" psql -X -v ON_ERROR_STOP=1 \
    --single-transaction -h 127.0.0.1 -U n8n -d n8n < "$DUMP_PATH"; then
  echo 'Restore failed; never promote this staging volume' >&2
  exit 1
fi
docker exec "$ID" psql -X -v ON_ERROR_STOP=1 -h 127.0.0.1 -U n8n -d n8n \
  -c "SELECT count(*) AS public_tables FROM information_schema.tables WHERE table_schema='public';"
printf 'Restore parsed successfully. Staging container: %s; volume: %s\n' "$ID" "$VOL"

A successful SQL import is only the database layer. Compare expected table/row counts and known records; the displayed table count alone is not a pass. Next rehearse an isolated n8n restore with matching version, persistent files and encryption key, all triggers disabled and outbound side effects denied, before checking login, workflows and credential use. Do not connect a restored production workflow to real publishers as a test. The database container stops on script exit; record its printed/generated ID, inspect it with docker ps -a, and remove only that exact disposable container and volume after testing. A failed drill retains data for diagnosis and needs the same deliberate cleanup. Never use a broad volume prune.

This is a portable-export drill, not Contabo Auto Backup restore. Auto Backup restore overwrites the same VPS and takes it offline; practice that separately only on a disposable VPS using its own backup.

Notice periods and confirmation

Contabo product terms can require notice before term end. A reminder set one week out can be too late if Contabo’s applicable notice is longer. Read Contabo’s current VPS product notes and terms for your contract length, then set the reminder earlier than the deadline with margin.

When Contabo’s panel shows a cancellation date, screenshot or save it with the service ID and IP. If you later need Contabo support for a renewal/refund case, that evidence shortens the ticket. Confirm data-loss language Contabo requires—especially for 14-day revocation (private accounts) or 72-hour auto-renew refunds (not for customers in Germany per Contabo’s refund article—verify live).

Where to go next

Contabo review Setup Policy hub Cost calculator

Sources and updates

• Contabo help — cancel service: close account / cancel service (verify live).
• Contabo help — refunds: Can I get a refund?; auto-renew: auto-renewed cancel; revocation: 14-day revocation (all verify live).
• Contabo Customer Panel cancel/backup UIs.
• Contabo Auto Backup / snapshot product pages; GPU VPS backup caveats.

• PostgreSQL pg_dump; psql restore error handling.

Last editorial pass: 2026-11-05 (America/Los_Angeles, PST). Contabo policies change— Contabo’s site wins.