Get Started

Create a provider organization

In the sidebar, open the organization menu → Add organization → choose Provider (sells services to clients) → enter your company name → Create Organization.

Verify your domain

On Provider onboarding, enter the domain you will list on the marketplace (for example acme.com) and choose a verification method:

Click Add Domain, apply the challenge, then Verify. DNS can take a few minutes to propagate.

Complete your organization profile

Fill in the details NodeRings uses for marketplace review and customer-facing listings:

• Organization name (legal company name)
• Support email, billing email, and support phone
• Business address (country, region, city, postcode)
• Tax identifiers (VAT ID, tax ID where applicable)
• DDoS provider and ASN (if you operate your own network)
• Provider logo (PNG or SVG, max 512 KB)
• Business owner name and social profiles (optional)

Request review

Click Request review and save. NodeRings reviews your listing; infrastructure unlocks after approval. Set up Stripe Connect under Organization → Billing → Payout when ready.

Create a Connect account

On Payout Methods → Connect Account, click Create Connect Account. NodeRings creates a Stripe Connect account linked to your provider organization and shows Connect Account Details (still Pending until Stripe onboarding finishes).

Complete Stripe onboarding

While status is Pending, charges and payouts stay disabled. Click Complete Setup & Onboarding to open Stripe’s hosted flow. Provide business and identity details (or reuse an existing Stripe account), then return to the dashboard.

Confirm Active

When onboarding succeeds, the account shows Active with Charges Enabled and Payouts Enabled. You can set a payout schedule under Payout Schedule. If Stripe Connect is not available in your country, use Manual Payout instead (funds are held longer before release).

Pick the geography

Select country and city that reflect where your Proxmox nodes actually run. This is what customers use to choose your plans.

Choose datacenter

Select the facility from the list, or choose Other if you do not want to disclose your datacenter provider on the marketplace. Other still lets you sell, only the specific facility name is hidden.

Choose availability zone

Pick zone_a, zone_b, or another zone only when the infrastructure is truly separate (distinct top-of-rack switches, routers, or hypervisor rows). If everything shares one fabric, use a single zone. Splitting zones without real isolation misleads customers about fault tolerance.

Save the region

Click Create Region. The region is then available when you attach nodes and plans.

Register the agent

Enter an agent name and the VM’s public IPv4 address. These are the only required fields to establish the secure channel between your site and NodeRings. Description is optional.

Choose gateway region

Select the gateway region closest to your agent VM. This is the datacenter where the NodeRings control-plane cluster runs. Picking a nearby gateway keeps the peering tunnel short and stable (for example Amsterdam if your agent sits in western Europe).

Provision on your agent VM

After you create the agent it appears as Unprovisioned. Select it in the list, open the Provisioning tab, and copy the Installation command. SSH into your Ubuntu agent VM and paste the command there. The script installs k3s, peers with NodeRings, and connects to your chosen gateway.

When prompted during install, provide your Proxmox URL and API token from Proxmox API user and token.

Add a platform

Click Add Platform. Give it a name, select driver Proxmox, and choose the agent you provisioned.

Set the endpoint URL

Enter the full API URL of your Proxmox cluster or host, for example https://192.168.1.100:8006/. Proxmox typically listens on port 8006 over HTTPS.

This can be a private or internal IP. The key requirement: the agent VM must be able to reach this URL. If it cannot call the Proxmox API, orders fail.

Add a node

Under your platform, click Add Node. Paste the node name exactly as shown in Proxmox.

Attach region

Select the region from §3 Region where this host physically sits. Customers buy by region; the node must belong to the correct one.

Set storage paths

Enter the Proxmox storage ID for new VM disks (VM disk storage) and for backups (Backup storage), for example local-lvm and local, as they appear under your node in Proxmox.

Backup compression and VMID seed

Choose backup compression (None, LZO, Gzip, or Zstd). Backups use vzdump snapshot mode so VMs keep running.

Set VMID seed to the first VM ID you want NodeRings to use on this node. If you set 9900, the first customer VM is 9900, the next 9901, and so on. Pick a range that does not collide with your existing VMs or templates.

Resource overallocation

Set CPU, memory, and storage overallocation percentages for this node:

At 100%, assets get dedicated resources; higher values allow resource sharing. The trade-off is yours, based on the quality of service and customer mix you target. The same logic applies separately to CPU, memory, and storage. A plan still cannot exceed a single node’s physical size (an 8-core node cannot sell a 16 vCPU plan regardless of overallocation).

Copy Ubuntu/Debian

In the sidebar, click New → Ubuntu/Debian. NodeRings opens a draft with user_data, vendor_data, and network_data pre-filled for static IP provisioning.

Adjust for your guest OS

Review network-data: the seed matches any Proxmox virtio NIC (match: driver: virtio_net), so it works across Ubuntu, Debian, Rocky, Fedora, and other distros without hard-coding interface names. Set storage to the Proxmox datastore ID used for cloud-init ISOs on your nodes (default local).

Save your template

Save each file (user_data, vendor_data, network_data) from the editor. NodeRings pushes compiled resources to agents linked through your VM templates in the next step.

Give the template a clear name (for example Ubuntu 24.04 cloud-init).

Create template images on Proxmox

Pick a per-OS tab or Seed all templates for the full catalog (VMIDs 15000–15013; edit VMID_BASE if needed). Install wget curl jq xz-utils qemu-utils libguestfs-tools on the Proxmox node first.

Details on disk size, --cpu host, firmware, and cloud-init: VM templates: CLI scripts.

#!/usr/bin/env bash
# Run on a Proxmox node as root. Adjust STORAGE/BRIDGE if needed.
# UEFI: include Proxmox cloud-init drive (scsi1) at create time. Legacy BIOS: OS disk only.
# NodeRings removes template cloud-init drives and injects cidata on ide2 at provision time.
set -euo pipefail

command -v qm >/dev/null || { echo "Run this on a Proxmox node (qm not found)"; exit 1; }

storage_supports_images() {
  local st=$1 content
  content=$(pvesm status -storage "$st" 2>/dev/null | awk -v s="$st" 'NR>1 && $1==s { print $3; exit }')
  [[ "$content" == *images* ]]
}

resolve_storage() {
  local st
  if [[ -n "${STORAGE:-}" ]]; then
    if storage_supports_images "$STORAGE"; then echo "$STORAGE"; return; fi
    echo "STORAGE=$STORAGE does not support VM disk images" >&2; exit 1
  fi
  for st in local-lvm local; do
    if storage_supports_images "$st"; then echo "$st"; return; fi
  done
  st=$(pvesm status -content images 2>/dev/null | awk 'NR>1 { print $1; exit }')
  [[ -n "$st" ]] && { echo "$st"; return; }
  echo "No storage with VM disk image support. Set STORAGE= explicitly." >&2; exit 1
}

STORAGE=$(resolve_storage)
echo "Using storage: $STORAGE"
BRIDGE="${BRIDGE:-vmbr0}"
WORKDIR="${WORKDIR:-/tmp/noderings-vm-templates}"
VMID=15000
NAME="ubuntu-2204-template"
IMG="ubuntu-2204.img"
URL="https://cloud-images.ubuntu.com/jammy/current/jammy-server-cloudimg-amd64.img"

if qm config "$VMID" &>/dev/null; then
  echo "VMID $VMID already exists. Destroy it first: qm destroy $VMID --purge 1"
  exit 1
fi

mkdir -p "$WORKDIR"
cd "$WORKDIR"

echo "Downloading $NAME ..."
wget --show-progress -L -O "$IMG" "$URL"
[[ -s "$IMG" ]] || { echo "Download failed: empty file"; exit 1; }
[[ $(stat -c%s "$IMG") -gt 100000000 ]] || {
  echo "Download failed: file too small ($(stat -c%s "$IMG") bytes). Check URL:"
  echo "  $URL"
  exit 1
}
qemu-img resize "$IMG" 5G 2>/dev/null || true

qm create "$VMID" --name "$NAME" --memory 1024 --cores 1 --cpu host \
  --net0 "virtio,bridge=${BRIDGE},firewall=1" \
  --bios ovmf --agent enabled=1 \
  --efidisk0 "${STORAGE}:${VMID},efitype=4m" \
  --ostype l26 --serial0 socket --vga serial0 --machine q35 \
  --scsi1 "${STORAGE}:cloudinit" --scsihw virtio-scsi-pci \
  --sockets 1 --numa 0

qm set "$VMID" --scsi0 "${STORAGE}:0,import-from=${WORKDIR}/${IMG}"
qm set "$VMID" --boot c --bootdisk scsi0
qm disk resize "$VMID" scsi0 5G 2>/dev/null || true

VOLID=$(qm config "$VMID" | sed -n 's/^scsi0:.*:\(vm-[0-9]*-disk-[0-9]*\).*/\1/p')
DISK=$(pvesm path "${STORAGE}:${VOLID}")
if [[ -b "$DISK" ]]; then
  [[ $(blockdev --getsize64 "$DISK") -gt 104857600 ]] || { echo "Import empty (block device too small)"; exit 1; }
else
  [[ $(du -k "$DISK" | cut -f1) -gt 102400 ]] || { echo "Import empty"; exit 1; }
fi
disk_has_partitions() {
  local disk_path=$1
  if sgdisk -p "$disk_path" 2>/dev/null | grep -qE '^[[:space:]]*[0-9]+[[:space:]]'; then return 0; fi
  if fdisk -l "$disk_path" 2>/dev/null | grep -qE '^/dev/'; then return 0; fi
  return 1
}
if ! disk_has_partitions "$DISK"; then
  echo "No partition table on imported disk"
  exit 1
fi

qm template "$VMID"
rm -f "$IMG"

echo "Template ready: VMID $VMID ($NAME)"

Register in NodeRings

Click Create VM Template. Select node, distro, enter the Proxmox template ID (VMID), and link your cloud-init from §6.

Cover the full catalog

Preflight expects every OS below on each sell-path node (registered in NodeRings).

Create a network

Name the network, set DNS servers, and assign nodes that will sell VMs from this pool.

Add prefixes

Add at least one IPv4 and one IPv6 prefix. Set each prefix gateway and mark infrastructure addresses as reserved so NodeRings never auto-assigns them.

Reserve external use

If part of a prefix is used by your own internal customers or DHCP elsewhere, reserve those IPs in NodeRings so they stay out of the customer pool. You can automate reserve/unreserve via the IPAM API.

Create a plan

Plans tab → Create Plan → choose billing type, region, and template (start with SC-GC-2C-4G-80). Set base price and Bandwidth Egress Gb (free units, overage rate, or unlimited).

Create addons

Addons tab → create addons with the same billing type as the plan (backups, additional IPs, snapshot storage).

Test with Price Calculator

Use the Price Calculator tab (?t=price-calculator) to estimate totals. Testing only.

Wait for preflight to go green

Fix red gates (agent, platform, node, templates, IPAM, addons). The next automatic cycle usually picks up changes within a few minutes.

Run live validation per plan × node

Use Start validation for every combination you sell on. Repeat when you add nodes or plans.

Confirm marketplace ready

Summary shows Ready with no blockers, and live validation shows Validated: Yes for at least one node in the sell region.

Customers can find and buy your plan

On the client marketplace (Create Virtual Machine → filter by region and plan size), your organization name, plan price, and listing details appear under recommendations. If preflight or live validation fails later, the plan drops out of search until you fix it.