NovaPod Docs

NovaPod is a high-performance GPU cloud for building, training, and serving AI models. Launch a GPU container pod with JupyterLab or VS Code in under 15 seconds, run a full KVM virtual machine with root access, deploy an autoscaling LLM endpoint, and connect everything with high-speed private networking and shared NVMe storage. You pay by the second with cryptocurrency, with zero mandatory KYC and zero hidden fees.

Create an accountLaunch a GPUInstall the CLI

---

What do you want to do?

⚡

Instances (Pods)

Interactive development with JupyterLab, VS Code, or SSH. Pre-loaded PyTorch and vLLM. Pause anytime and pay only storage.

🖥️

Root KVM VMs

Full root SSH from minute one. Run your own Docker or Kubernetes, custom kernel modules, eBPF, with static public IPs.

🚀

Serverless Endpoints

OpenAI-compatible APIs powered by vLLM, SGLang, or Ollama. Auto-scaling worker pools with scale-to-zero efficiency.

💻

CLI & Python SDK

Automate your hardware orchestration from terminal or scripts. Native skills for Claude Code, Cursor, and autonomous agents.

🎨

Deploy Apps & UIs

Instant production deployment for ComfyUI + Flux.1, Stable Diffusion WebUI, FastAPI, Gradio, and Streamlit interfaces.

🪙

Crypto Settlement

Deposit USDT, USDC, SOL, ETH, or BNB. Second-by-second precision deductions with zero subscription contracts or credit card declines.

---

Quickstart

Every compute deployment requires an account with credit balance. Create your account with email or WebAuthn passkey, then load crypto credits.

Web Console

1. Open the NovaPod Marketplace or Templates.
2. Choose your GPU model (e.g., NVIDIA H100 SXM5, H200, RTX 5090, or RTX 4090), select storage size and preferred region.
3. Select your pre-configured stack (e.g., PyTorch 2.4 + CUDA 12.4, vLLM Inference Server, or ComfyUI Flux).
4. Click Launch Pod. Within 15 seconds, the status transitions to Running.
5. Connect immediately via the JupyterLab web URL, open VS Code Web, or copy the direct SSH command.
6. When your job completes, click Pause to halt GPU compute charges while preserving your NVMe environment. Click Destroy when fully done.

NovaPod CLI (np)

Install the official np command-line tool via npm or Python pip:

# Install NovaPod CLI tool
curl -fsSL https://cli.novapod.io/install.sh | bash

# Authenticate your terminal
np setup --api-key np_live_your_secret_key

# Search available spot GPU offers
np search --gpu H100_SXM --count 1 --sort price

# Launch a pod with pre-installed PyTorch & JupyterLab
np launch --gpu H100_SXM --template pytorch --disk 80GB --name experiment-01

# Run an ad-hoc training script and stream logs back
np run train.py --gpu RTX_4090 --requirements requirements.txt

# SSH directly into your running machine
np ssh <machine_id>

# Pause instance to stop compute billing (storage persists)
np pause <machine_id>

Python SDK

Orchestrate training runs or batch inference pipelines directly in Python:

import novapod

# Initialize the client with your API key
client = novapod.Client(api_key="np_live_your_secret_key")

# Deploy a high-throughput GPU pod
pod = client.pods.create(
    gpu_type="NVIDIA H200 SXM5",
    gpu_count=1,
    template="vllm-openai",
    disk_gb=100,
    name="llama3-70b-serving"
)

# Wait until the container has finished cold-boot (<15s)
pod.wait_for_running()

print(f"JupyterLab URL: {pod.jupyter_url}")
print(f"Direct SSH: {pod.ssh_command}")
print(f"REST API Endpoint: {pod.endpoints['http-8000']}")

# Pause compute when batch job completes
pod.pause()

cURL / REST API

Programmatically launch instances from any autonomous AI agent, CI/CD pipeline, or webhook:

curl -X POST https://api.novapod.io/v1/rentals \
  -H "Authorization: Bearer np_live_your_secret_key" \
  -H "Content-Type: application/json" \
  -d '{
    "gpu": "H100-SXM",
    "gpu_count": 8,
    "template": "vllm-openai:latest",
    "disk_gb": 120,
    "settlement": "crypto_usdt"
  }'

---

Choosing compute

NovaPod allows you to choose exactly how much of the underlying infrastructure stack you want to own:

Feature	Instance (Docker Pod)	Root KVM VM	Serverless Endpoint
Best for	Interactive development, notebooks, model training, rapid prototyping	Custom kernel modules, Docker-in-Docker, k3s, long-running services	Production LLM serving, variable traffic, multi-turn AI agents
What you get	Lightweight container with direct GPU passthrough, JupyterLab & SSH	Full virtual machine with root access, custom OS kernel, and dedicated public IP	OpenAI-compatible HTTPS API endpoint (vLLM / SGLang / Ollama)
Boot Latency	< 15 seconds (pre-cached weights & image layers)	60 – 90 seconds (full OS kernel boot & cloud-init)	Instant (pre-warmed worker pool) or scale-to-zero
Root & Kernel Control	Root inside container; shared host kernel	Full bare-metal/KVM root; custom kernel modules, eBPF, sysctl	Fully managed inference runtime
Operating Systems	Linux (Ubuntu / Debian with CUDA 12.4+ runtimes)	Ubuntu 24.04 LTS, Debian 12, or Windows Server GPU	Managed Linux serving container
Storage Persistence	Persistent Shared Network Volumes + ephemeral scratch disk	Dedicated NVMe system disk preserved across stop/pause cycles	Model storage + ephemeral context caching
Public IP & Networking	Dynamic port forwarding with HTTPS reverse proxy	Dedicated static public IPv4 with all ports configurable	Secure HTTPS endpoint with global DDoS protection
Billing Model	1-second precision while active; $0 when destroyed	1-second precision for GPU; $0.00014/GB/hr storage when paused	Per minute of active worker runtime, or per token consumed

---

All products

⚡ Compute

• Docker Pods: Instant GPU containers with pre-installed PyTorch, CUDA, and JupyterLab.
• Root KVM VMs: Dedicated virtual machines with root SSH, custom kernel support, and static IPv4.
• Serverless LLM Endpoints: Auto-scaling OpenAI-compatible endpoints backed by vLLM & SGLang.
• Persistent Environments: Python virtual environments that persist across pause and resume.

🌐 Networking

• Private VPC: Interconnect your GPU nodes on isolated tenant subnets.
• Reserved Static IPs: Hold public IP addresses across instance restart cycles.
• Security Groups: Inbound and outbound firewall allowlists for zero-trust traffic.

💾 Storage & Data

• Shared Filesystems: 25 Gb/s multi-instance network storage for large checkpoints and datasets.
• Object Storage (S3): S3-compatible buckets for model weights and training datasets.
• Download Data: Accelerated data ingestion tools from HuggingFace, Kaggle, CivitAI, and S3.

🛠️ Developer Tools

• NovaPod CLI: Complete command-line management for terminal and automated pipelines.
• Python SDK: Programmatic GPU provisioning, status polling, and instance teardown.
• Agent Skills: Turnkey tools for Cursor, Claude Code, and autonomous coding agents.

💳 Account & Billing

• Crypto Settlement: Deposit USDT, USDC, SOL, ETH, or BNB with 1-confirmation automatic reflect.
• Settings & Wallet: API keys, startup scripts, and billing thresholds.
• Team Credit Pools: Multi-seat credit sharing and audit logs.

---

Need help?

• Check Troubleshooting for common CUDA driver mismatch and OOM resolutions.
• Browse the FAQs for billing, storage, and networking questions.
• Reach out to our 24/7 developer engineering team at support@novapod.io.