Skip to main content
This guide is for teams that run GPU workloads on Paperspace or on DigitalOcean’s own GPU products and want to run them on Runpod. Paperspace Machines and DigitalOcean GPU Droplets map to Pods, Notebooks map to Pods with JupyterLab, Deployments map to Serverless endpoints, Workflows map to the Runpod SDK or Serverless queue endpoints, and DigitalOcean Inference maps to Public Endpoints or a Serverless vLLM endpoint. By the end you’ll have each workload running on Runpod, your data on Runpod storage, your clients and automation pointed at Runpod, and the old resources shut down.
You can hand most of this migration to a coding agent. See Migrate with a coding agent.
Product names, checked against DigitalOcean’s docs on 2026-11-14. Paperspace is part of DigitalOcean and still offers Notebooks, Deployments, Workflows, and Machines through the Paperspace console. “Gradient” still names those Paperspace products and their subscription plans. DigitalOcean’s own AI products are GPU Droplets, Bare Metal GPUs, and Inference (serverless inference, dedicated inference, and Agent Platform). DigitalOcean’s docs list no retirement date for the four Paperspace products. They do state that the legacy Gradient and Core API endpoints are no longer available (so the gradient CLI no longer works), that Windows templates are unavailable to users who joined after July 1, 2024, and that NVIDIA GRID machines are retired.

How Paperspace and DigitalOcean map to Runpod

What’s different

What works differently

VMs become containers. A Paperspace Machine or a GPU Droplet is a virtual machine: you pick an OS image, get a boot disk that persists everything, and can install drivers, run systemd services, or run Docker yourself. A Pod is a single container that Runpod starts from your Docker image, with the GPU drivers provided by the host. Anything you installed by hand on the VM has to move into a Dockerfile. Runpod runs Docker for you, so you can’t start your own Docker daemon or use Docker Compose inside a Pod. Only /workspace persists. On a VM the whole boot disk survives a shutdown. On a Pod, the container disk resets when the Pod stops, the volume disk at /workspace survives a stop and is deleted with the Pod, and a network volume outlives the Pod. Keep code, data, and checkpoints under the mounted path, and install system packages in the image. Stopping and billing. Paperspace bills machine compute only while the machine is powered on, and keeps billing storage and public IPs. DigitalOcean keeps billing a powered-off GPU Droplet until you destroy it. A stopped Pod stops billing compute and keeps billing its volume disk. A Serverless endpoint with zero active workers bills only while workers run. See Pod pricing and Serverless pricing. Public access. A Machine or Droplet gets a public IP address where every port you open is reachable. A Pod exposes only the ports you list. HTTP ports get a URL of the form https://POD_ID-PORT.proxy.runpod.net, which is public, has no built-in authentication, and closes connections after 100 seconds. TCP ports (such as SSH) get a public IP and a mapped external port that Runpod assigns. Pods support TCP and HTTP, not UDP. Deployment endpoints. A Paperspace Deployment serves your container at a paperspacegradient.com URL, optionally protected with basic authentication (username paperspace). A Runpod load-balancing endpoint serves your container at https://ENDPOINT_ID.api.runpod.ai and always requires Authorization: Bearer YOUR_API_KEY. A queue-based endpoint uses a different contract: you write a handler function and clients call /run or /runsync with an {"input": {...}} body. Autoscaling signals. Paperspace Deployments scale between replicas and maxReplicas on CPU, memory, or request duration, using the Kubernetes horizontal pod autoscaler. Runpod endpoints scale between a minimum and maximum worker count on request count (load balancing and queue-based) or queue delay (queue-based only). The minimum is 0 by default, so an endpoint scales to zero and the first request after idle pays a cold start. Health checks. Paperspace supports liveness, readiness, and startup probes with any 2xx or 3xx code as success. A load-balancing worker has one health path (/ping by default, configurable with HEALTH_CHECK_PATH) where 200 means healthy, 204 means initializing, and anything else means unhealthy. Model APIs. DigitalOcean serverless inference authenticates with a model access key against https://inference.do-ai.run/v1 and includes commercial third-party models. Runpod Public Endpoints and vLLM endpoints authenticate with your Runpod API key and include the endpoint or model slug in the base URL. One credential. Paperspace and DigitalOcean use separate credentials (a Paperspace API key, a DigitalOcean personal access token, model access keys, and Spaces keys). Runpod uses one API key for the CLI, REST API, SDK, and endpoint requests, plus a separate S3 API key for the S3-compatible API.

What has no direct equivalent

On Runpod:
  • Windows machines and desktop streaming. Pods run Linux containers. Keep Windows workloads where they are, or port them to Linux. For interactive work, use JupyterLab, SSH, or an IDE connection.
  • A Kubernetes API. DOKS GPU node pools have no Runpod counterpart you can point kubectl at. Move each workload to the product that fits its shape: a Deployment with a Service to a Serverless endpoint, a Job to @app.task or a queue-based endpoint, a StatefulSet or long-lived process to a Pod, and tightly coupled multi-node training to an Instant Cluster. To keep a cluster-style scheduler, use the SkyPilot or dstack integration.
  • VM snapshots and custom OS templates. Rebuild the environment as a Docker image and store its settings in a template.
  • A workflow engine. Gradient Workflows runs YAML job graphs with typed inputs and outputs. On Runpod, job order lives in Python (the SDK) or in your CI system.
  • Versioned datasets. Paperspace datasets have immutable versions and tags. On a network volume, use versioned directory names, or keep datasets in an object store that supports versioning.
  • Object storage buckets with a CDN. The S3-compatible API reads and writes files on a network volume. It isn’t a bucket service with public URLs or a CDN. Keep Spaces for public assets.
  • Managed agents, knowledge bases, and commercial model routing. Agent Platform, Knowledge Bases, the Inference Router, and third-party commercial models stay on DigitalOcean or move to another provider.
  • Raw block devices. Network volumes mount as a file system. You can’t partition or format them.
  • Multiple probe types. Fold readiness and startup logic into the single health path.
On the Paperspace and DigitalOcean GPU products this guide covers:
  • Scale to zero for your own containers. Paperspace replicas is the floor for a running Deployment, and you stop it by setting enabled: false.
  • A managed request queue. Queue-based endpoints give you async jobs, status polling, streaming, retries, and webhooks without running a queue yourself.
  • Storage that isn’t tied to a region. A global volume (beta) mounts in any data center.
  • Ephemeral compute per function call. @app.task provisions a Pod per call and terminates it when the function returns.

Requirements

  • A Runpod account with credits, and a Runpod API key.
  • Access to your Paperspace team (a Paperspace API key for pspace) or your DigitalOcean team (a personal access token for doctl), or both.
  • Docker on your machine, and a container registry you can push to (Docker Hub, GHCR, or DigitalOcean Container Registry).
  • An SSH key pair for Pod access and file transfer.
  • For Terraform users: Terraform 1.6 or later.

Step 1: Take inventory of what you run on Paperspace and DigitalOcean

List every resource, record its configuration, and find the code that calls either platform. Use the names from each product’s API, because you’ll map them field by field in later steps.

Paperspace

Install pspace and log in with a Paperspace API key, then list the resources it manages. The --json flag is available on every command.
For each machine, record machineType, region, diskSize, templateId, publicIpType, networkId, startupScriptId, and the auto-shutdown settings. Secret values aren’t needed yet, only the names. Export the full configuration of each Deployment. The response includes the spec (image, port, env, command, instance type, replicas, autoscaling, health checks, and integrations) and the endpoint URL.
The same data is available from the Paperspace API at https://api.paperspace.com/v1, for example GET /deployments, GET /machines, GET /shared-drives, and GET /datasets, with an Authorization: Bearer header. pspace has no commands for Notebooks, Workflows, or datasets. For those, use the Paperspace console:
  • Notebooks: For each Notebook, record the container image, the workspace repository URL, the machine type, and what you keep in /notebooks, /storage, and /datasets.
  • Workflows: Workflow specs live in your repository under .gradient/workflows. Record each job’s instance-type, image, inputs, outputs, env, and needs.
  • Datasets and models: Record each dataset ID and its storage provider (Gradient-managed or your own S3-compatible bucket).

DigitalOcean

Install doctl, authenticate with a personal access token, and list GPU resources. doctl compute droplet list returns only non-GPU Droplets unless you pass --gpus.
For each GPU Droplet, record the size slug (for example gpu-h100x1-80gb), the image slug (gpu-h100x1-base, gpu-h100x8-base, gpu-amd-base, a 1-Click Model, or your own snapshot), region, attached volume IDs, VPC, tags, and the user data script. For DOKS, record which node pools use gpu- size slugs and which workloads schedule onto them. List dedicated inference deployments with the DigitalOcean API:
For serverless inference, list your model access keys in the DigitalOcean Control Panel and note which model IDs your applications request. For Spaces, list buckets with any S3 client pointed at your region’s endpoint, for example aws s3 ls --endpoint-url https://nyc3.digitaloceanspaces.com.

Find code that calls either platform

Search your repositories for CLI invocations, hostnames, credentials, and Terraform resources:
Also check for hardcoded paths that only exist on the old platform: /notebooks, /storage, /datasets, /inputs, /outputs, /home/paperspace, and Droplet volume mount points under /mnt.

Step 2: Set up Runpod

Create a Runpod account, add credits, and create an API key. Then install the tools you’ll use. Install runpodctl and configure it. runpodctl doctor sets your API key and an SSH key in one pass.
On macOS you can use brew install runpod/runpodctl/runpodctl instead. Install the Runpod SDK if you’ll migrate Workflows, write Serverless handlers, or call endpoints from Python. It requires Python 3.10 to 3.14 and includes the rp CLI.
rp login stores your key in ~/.runpod/config.toml. The RUNPOD_API_KEY variable is what the REST examples and the Terraform provider in this guide read. To let a coding agent manage Runpod for you, connect the Runpod MCP server. For infrastructure as code, install the Terraform provider.

Step 3: Choose where each workload lands

Pick a target for each item in your inventory by its shape, not by the product it runs on today.

Map your GPUs

Choose a GPU by what the workload needs (VRAM first, then generation), then confirm stock. The Runpod IDs below come from the GPU types reference. Pods take a GPU type ID. Serverless endpoints take a GPU pool ID. GPU stock varies by data center and changes through the day, so check what’s available before you commit to a type:
For AMD GPU Droplets, check both that an AMD GPU type has stock and that your software stack (ROCm) has a matching image. The official PyTorch templates include one ROCm variant. If you move from AMD to NVIDIA GPUs, rebuild on a CUDA base image.

Step 4: Move your images and code

Every Runpod target runs a linux/amd64 Docker image. What you do here depends on whether the source is already a container.

Machines and GPU Droplets: turn the VM into an image

Write a Dockerfile that reproduces what you installed on the VM. Start from a Runpod PyTorch image so you get CUDA, SSH, and JupyterLab conventions that the platform already understands.
Dockerfile
The Ubuntu 24.04 base image marks the system Python as externally managed, which is why the install uses --break-system-packages. Build for linux/amd64 and push to a registry Runpod can pull from:
If you build on an Apple silicon Mac, the --platform flag is required. Without it the image is arm64 and the Pod fails to start. Translate the rest of the VM setup as follows:
  • GPU drivers and CUDA. Don’t install NVIDIA drivers in the image. The host provides them. Your image supplies the CUDA user-space libraries, and you set a CUDA floor when you create the Pod (--min-cuda-version 12.8) so it lands on a host whose driver supports your image.
  • Startup scripts and user data. A Paperspace startup script or Droplet user_data (cloud-init) becomes either Dockerfile steps (for installs) or the container start command (for launching your process).
  • Docker and Docker Compose on the VM. If the Droplet ran docker run --gpus all your-image, that image is your Pod image, and the docker run flags become template fields: -p becomes ports, -e becomes env, -v becomes a volume mount, and the trailing command becomes the start command. For a Compose stack, run one Pod per service and connect them with global networking (NVIDIA GPU Pods only), or combine the services into one image with a process supervisor.
  • systemd services. A container has one main process. Run your service in the foreground as the start command.
  • The paperspace user. Paperspace Linux machines provision a paperspace user with a home directory at /home/paperspace. Runpod’s SSH examples connect as root, and persistent data lives in /workspace. Update hardcoded paths.
  • ML-in-a-Box and the AI/ML-ready image. Both are VM images with a preinstalled stack. The closest starting point is a runpod/pytorch image plus your own requirements.txt.
For a private registry, save credentials once and reference them when you create Pods, templates, or endpoints:

Notebooks: reuse the container or switch to the PyTorch template

A Paperspace Notebook already runs in a container (for example paperspace/gradient-base), with your files in /notebooks. You have two options:
  • Use the official PyTorch template (runpod-torch-v280), which starts JupyterLab on port 8888 and mounts /workspace. Reinstall your Python packages from a requirements.txt kept in /workspace. This is the shortest path.
  • Build your own image from runpod/pytorch with your packages baked in, as in the Dockerfile above, if you want the environment to survive Pod deletion.
Either way, change notebook code that reads /notebooks, /storage, or /datasets to read from /workspace.

Deployments: keep the image, adjust the health check and port

A Deployment image already serves HTTP, so it can run as a load-balancing worker with configuration changes only. The worker must do two things: listen on the port named by the PORT environment variable, and answer a health check. If your app already has a readiness route, point Runpod at it with HEALTH_CHECK_PATH instead of changing code. If it has none, add a /ping route. This FastAPI app is the Paperspace health check example adapted for Runpod: it returns 204 while the model loads and 200 when it’s ready.
The request and response bodies don’t change. What changes is the health route, the port source, and (in Step 7) the URL and auth header your clients send. To use a queue-based endpoint instead, replace the HTTP server with a handler. Clients then send {"input": {...}} to /run or /runsync instead of calling your paths.
handler.py
The image for a queue-based worker needs pip install runpod and a start command of python -u handler.py. See Handler functions for streaming and async handlers.

Workflows: rewrite the job graph in Python

A Workflow spec declares jobs, their order (needs), and data passed through /inputs and /outputs. With the Runpod SDK, each job becomes a function decorated with @app.task, the order becomes ordinary Python, and shared data moves through a network volume mounted on each task.
Each task call provisions a Pod, runs the function, and terminates the Pod when it returns. The needs relationship is now the order of the two .remote() calls, and /outputs/model and /inputs/model are one directory on a shared network volume. Create the secret with rp secret add hf_token before the first run, and check the short GPU names the SDK accepts in SDK GPU types. Workflows that a GitHub push triggers through the Gradient GitHub App need a new trigger. Run the pipeline from your CI system with rp flash dev main.py --once, which runs the entrypoint once and exits.

Runtime environment variables

Review code that reads platform-injected variables or fixed paths. See the Environment variable map.

Step 5: Move your data and models

First decide where each data set lives on Runpod:
A network volume lives in one data center, and every Pod or worker that mounts it runs there. Choose a data center that has stock for the GPU you picked in Step 3, and prefer one that supports the S3-compatible API so you can transfer files without a running Pod.
Create the network volume:
Size is in GB (10 to 4096) and can grow later but not shrink.

From a Machine, Droplet, or DigitalOcean Volume: push with the S3-compatible API

The source VM can push straight to the network volume, with no Pod running. Create an S3 API key on the Credentials page (it’s separate from your Runpod API key), then run the AWS CLI on the Machine or Droplet:
The bucket name is the network volume ID, and object keys are file paths: s3://NETWORK_VOLUME_ID/datasets/a.bin appears at /workspace/datasets/a.bin on a Pod and /runpod-volume/datasets/a.bin on a Serverless worker. aws s3 sync can struggle with more than about 10,000 files, so for directories with many small files, create a tar archive first and copy that with aws s3 cp.

From a Machine or Droplet: push over SSH with rsync

If the data center you chose doesn’t support the S3-compatible API, or you want rsync semantics, start a Pod with the network volume attached and push over SSH. Register the source VM’s public key with Runpod before you create the Pod, because keys are injected at creation.
runpodctl ssh info prints the host, port, and key to use. rsync needs the direct SSH connection, which is why the Pod exposes 22/tcp and uses an official Runpod image that starts an SSH server. Install rsync on the Pod first (apt update && apt install -y rsync). If runpodctl ssh info reports no public IP, recreate the transfer Pod as a GPU Pod on Secure Cloud. Delete the transfer Pod when the copy finishes.

From a Notebook or a dataset

Open a terminal in the Notebook, where /notebooks, /storage, and mounted datasets under /datasets are all visible, and push to the network volume with the S3-compatible API:
For notebooks tracked in Git, cloning the repository into /workspace on the Pod is simpler than copying files.

From Spaces

Spaces is S3-compatible, so you can copy from it with the AWS CLI from inside a Pod that has the network volume mounted. Use a named profile for the Spaces keys so they don’t collide with other credentials.
Replace nyc3 with your bucket’s region. Running this inside a Pod writes straight to the volume’s file system. You can also leave data in Spaces and keep reading it from Runpod with the same S3 client code, since only the compute moved.

Models

For Hugging Face models on Serverless, attach the model to the endpoint instead of copying weights: add --model-reference to the runpodctl serverless create command you run in Step 6, as in the example below. Runpod stages it on the host before the worker starts, and it appears under /runpod-volume/huggingface-cache/hub/. This replaces a Paperspace Deployment git-lfs integration that clones a Hugging Face URL into /models.
Point your model loading code at the cache path, or load by model ID and let the Hugging Face libraries resolve it. See Cached models.

Step 6: Deploy on Runpod

Deploy a Pod (from a Machine or GPU Droplet)

Create the Pod from your image with the GPU, storage, and ports from your inventory. This is the equivalent of pspace machine create or doctl compute droplet create.
The Pod’s data center must match the network volume’s. To use a volume disk instead of a network volume, replace --network-volume-id with --volume-in-gb 500 (REST: "mounts": {"persistent": {"size": 500, "path": "/workspace"}}). A volume disk is tied to the Pod’s host and is deleted with the Pod, so use a network volume for data you can’t recreate. In the console, the same flow is Pods, then Deploy. Wait for the Pod and connect:
runpodctl pod get reports runtimeStatus: running when the container is up. HTTP ports are at https://POD_ID-8888.proxy.runpod.net.

Deploy a notebook Pod (from a Notebook)

Create a Pod from the official PyTorch template and set JUPYTER_PASSWORD, which the template uses as the JupyterLab token. JupyterLab starts only when that variable is set.
Open https://POD_ID-8888.proxy.runpod.net and enter the token. Deploying the same template from the console sets the token for you. Stop the Pod when you finish a session (runpodctl pod stop POD_ID) and start it again later (runpodctl pod start POD_ID): /workspace is kept, and packages installed outside /workspace are not.

Deploy a load-balancing endpoint (from a Deployment)

Create the endpoint with REST API v2. The endpoint type is set at creation and can’t change later. runpodctl serverless create creates queue-based endpoints, so use REST, Terraform, or the console for load balancing.
The response includes requestUrls.base (https://ENDPOINT_ID.api.runpod.ai) and requestUrls.health. Set both PORT and PORT_HEALTH to your server’s port and list the same port in ports: each defaults to 80 on its own, and a mismatch leaves the worker unhealthy. {{ RUNPOD_SECRET_hf_token }} reads a Runpod secret named hf_token, which you create in the console or with POST /v2/account/secrets. This request sets HEALTH_CHECK_PATH to /ping, so it needs the image rebuilt with the /ping route from Step 4. An unchanged Paperspace image has no /ping route, and its workers never become healthy. Load-balancing endpoints scale on REQUEST_COUNT only. workers.min of 0 scales to zero. Set it to 1 or more to keep warm workers, which is the closest match to Paperspace replicas. In the console, the same flow is Serverless, then New Endpoint.

Deploy a queue-based endpoint (from a Deployment or a fan-out Workflow)

Create a Serverless template for the handler image, then an endpoint from it. A Serverless template binds to one endpoint.
--scale-by delay adds workers when requests wait longer than the threshold in seconds. --scale-by requests scales on pending request count. You can also deploy a handler straight from a repository with the GitHub integration, which builds the image for you.

Deploy a vLLM endpoint (from serverless inference, dedicated inference, or a 1-Click Model)

Deploy the vLLM worker from the Hub with the Hugging Face model you served on DigitalOcean:
The Hub release supplies the GPU and disk defaults, and you can override the GPU with --gpu-id. For gated models, set a Hugging Face token as described in Get started with vLLM. If Runpod already hosts the model as a Public Endpoint, there’s nothing to deploy: go to Step 7.

Deploy an SDK app (from a Workflow)

Run the pipeline from Step 4 in a dev session, then deploy any @app.queue or @app.api resources in the app as production endpoints:
Tasks don’t need a deploy step. Each call provisions its own Pod. A task started with .spawn() keeps running and billing until it finishes if your script exits without waiting on it.

Step 7: Update the code that calls Paperspace and DigitalOcean

Deployment clients

For a load-balancing endpoint, change the base URL and the auth header. Paths and bodies stay the same.
Raise client timeouts and add retries for the first request after idle, because a cold start has to pull the image and load the model. If no worker is available within 2 minutes the request fails, and Runpod’s docs recommend at least 3 retries with 5 to 10 second delays. For a queue-based endpoint, wrap the body in input and choose sync or async:
client.py
The equivalent HTTP calls are POST https://api.runpod.ai/v2/ENDPOINT_ID/runsync and POST https://api.runpod.ai/v2/ENDPOINT_ID/run with Authorization: Bearer YOUR_API_KEY, then GET /status/JOB_ID. Results come back under output. To get a callback instead of polling, add "webhook": "https://your-app.example.com/hook" next to input. See Send requests.

OpenAI-compatible clients

If you call DigitalOcean serverless inference with the OpenAI SDK, swap the base URL, the key, and the model name.
On Runpod the endpoint ID or Public Endpoint slug is part of the base URL, so each model has its own base URL. vLLM endpoints support /chat/completions, /completions, and /models. If your code uses DigitalOcean’s /v1/responses, /v1/messages, /v1/embeddings, image, audio, or video routes, check OpenAI compatibility and the Public Endpoints reference for what’s available before you cut over. Calls made through PyDo (client.chat.completions.create on a pydo.Client) need to move to the OpenAI SDK or runpod.Endpoint. Dedicated inference clients change the same way: replace the do-infra.ai endpoint URL and its access token with the vLLM base URL and your Runpod API key. A private dedicated inference endpoint that you reach over a VPC with a CA certificate becomes a public HTTPS URL authenticated by API key. 1-Click Models serve the Hugging Face TGI API, so clients that call TGI-specific routes need to switch to the OpenAI-compatible routes.

Control-plane automation

Replace scripts that call pspace, doctl, the Paperspace API, or the DigitalOcean API with runpodctl or REST API v2. The full maps are in the Reference section. The pattern is the same throughout:
A Paperspace auto-shutdown timer has no setting to copy across. Pods come with runpodctl and a Pod-scoped API key preinstalled, so a job can stop its own Pod when it finishes: end your script with runpodctl pod stop $RUNPOD_POD_ID.

Step 8: Verify, cut over, and shut down

1

Send a real request from outside

Call each new endpoint from the same network your production clients use, with production-shaped inputs. For a load-balancing endpoint:
For a queue-based endpoint, check https://api.runpod.ai/v2/ENDPOINT_ID/health and send a /runsync request. For a Pod, open the proxy URL and run nvidia-smi over SSH.
2

Compare outputs and latency

Send the same inputs to the old and new deployments and compare results. Measure a cold request (after the endpoint has scaled to zero) and a warm one separately. If cold starts are too slow for your traffic, set a minimum worker count above 0, use cached models, or move weights from download-at-start to a network volume.
3

Run both in parallel and shift traffic

Keep the Paperspace or DigitalOcean deployment live. Route a small share of traffic to Runpod, watch error rates and logs, then increase the share. Keep the old deployment until you’ve run a full traffic cycle on Runpod.
4

Confirm your data

Verify file counts and checksums on the network volume before you delete any source disk, shared drive, dataset, or bucket. Paperspace snapshots are deleted when their machine is deactivated, so copy anything you need first.
5

Shut down Paperspace

Powering off a machine stops compute billing but storage, public IPs, snapshots, and templates keep billing until you delete them.
Deleting a machine (Paperspace calls this deactivating) permanently removes the machine, its files, and its snapshots, and the machine must be off first, so wait for pspace machine get MACHINE_ID to show it as off before you delete it. Delete Notebooks, Workflows, and datasets in the Paperspace console, and review your Gradient subscription plan there. Run pspace public-ip release --help and pspace snapshot delete --help for the exact arguments.
6

Shut down DigitalOcean

A powered-off GPU Droplet still bills. Destroy it, and remove the volumes and snapshots that the destroy leaves behind.
Droplet backups stay until their retention period ends. Delete Spaces buckets and model access keys in the Control Panel once nothing reads them. Revoke the Paperspace API keys and DigitalOcean tokens you created for the migration.
7

Guard costs on Runpod

Delete transfer Pods and stop development Pods you aren’t using (runpodctl pod list --all). Network volumes bill until you delete them, including ones the SDK creates for you such as pipeline-artifacts (runpodctl network-volume list). Keep endpoint minimum workers at 0 unless you need warm capacity, and set an idle timeout that fits your traffic. Review spend with runpodctl billing pods and runpodctl billing serverless, and turn on low balance notifications. When your balance reaches zero, Pods with a network volume are stopped, and Pods without one are terminated and their volume disk data can’t be recovered.

Migrate your Terraform

DigitalOcean resources are managed with the digitalocean/digitalocean provider. The Runpod provider (runpod/runpod, version 2.x) is built on REST API v2 and reads RUNPOD_API_KEY from the environment. Paperspace resources aren’t covered by the digitalocean provider, so recreate them from the inventory in Step 1. If your configuration uses the community Paperspace/paperspace provider, map paperspace_machine to runpod_pod the same way as digitalocean_droplet, and move paperspace_script contents into the image or the start command. The following example replaces a GPU Droplet with an attached volume.
The setup.sh user data script has no direct counterpart: its install steps move into the Docker image. Changing gpu_type_id, gpu_count, cloud, or data_center_ids replaces the Pod, so keep data on the network volume. For a Deployment or DOKS inference service, use runpod_serverless_endpoint with endpoint_type = "LOAD_BALANCER" or "QUEUE", gpu_pools, scaling_type, scaling_value, workers_min, and workers_max. For every argument, see the provider reference. Migrate in two applies: create the Runpod resources alongside the DigitalOcean ones, cut over, then remove the digitalocean_ resources and run terraform apply again to destroy them.

Reference

CLI command map

Run runpodctl COMMAND --help for current flags.

API map

All three APIs authenticate with Authorization: Bearer. Requests to deployed endpoints go to a different host than the management API: https://api.runpod.ai/v2/ENDPOINT_ID for queue-based endpoints and https://ENDPOINT_ID.api.runpod.ai for load balancing.

Configuration field map

Environment variable map

Status map

Queue-based jobs report IN_QUEUE, IN_PROGRESS, COMPLETED, FAILED, CANCELLED, or TIMED_OUT. See Job states.

Migrate with a coding agent

A coding agent can run the inventory, propose a plan, and perform the migration with the Runpod skills and MCP server.
1

Install the Runpod skills and MCP server

The plugin also connects the hosted MCP server.
The MCP server signs in with OAuth (“Sign in with Runpod”), so you don’t need an API key to start. See Agent skills and MCP servers.
2

Give the agent the migration prompt

Run your agent in the repository that contains your application code and infrastructure files, and paste this prompt:

Troubleshooting

The Pod starts but files I saved are gone after a stop. On a VM the whole disk persists. On a Pod only the volume mount does. Move the files to /workspace, and install system packages in the image instead of at runtime. JupyterLab returns a 502 on port 8888. The official PyTorch template starts JupyterLab only when JUPYTER_PASSWORD is set. Pods created from the console get it automatically. With runpodctl pod create, pass --env '{"JUPYTER_PASSWORD":"CHOOSE_A_TOKEN"}'. See Troubleshooting 502 errors. The container fails with a CUDA or driver error. A VM image carries its own driver. A Pod uses the host’s, and hosts differ. Set a CUDA floor that matches your image (--min-cuda-version on runpodctl, gpu.minCudaVersion in REST, min_cuda_version in Terraform), and remove any driver installation from your Dockerfile. exec format error when the Pod or worker starts. The image was built for arm64. Rebuild with docker buildx build --platform linux/amd64. The load-balancing endpoint returns 502 and workers never become healthy. The server isn’t listening where Runpod is checking. Set PORT and PORT_HEALTH to the port your server binds, list that port in ports, bind to 0.0.0.0, and make sure the health path returns 200. A readiness route that returns 503 while loading keeps the worker unhealthy: return 204 instead. Requests that worked on a Deployment now time out. Load-balancing endpoints cap each request at 5.5 minutes and 30 MB, and the Pod HTTP proxy closes connections after 100 seconds. Move long requests to a queue-based endpoint and poll or use a webhook, or expose a TCP port on a Pod. Clients get 401 after the cutover. Paperspace protected endpoints use basic authentication with the username paperspace. Runpod endpoints require Authorization: Bearer YOUR_API_KEY. For OpenAI-compatible clients, replace the model access key with your Runpod API key. The first request after idle is slow or fails. The endpoint scaled to zero and is cold starting. Retry with a delay on the client, raise workers.min, enable FlashBoot, or use cached models so weights don’t download on every cold start. runpodctl pod create fails for lack of capacity. The GPU type has no stock in the data center your network volume pins you to. Check runpodctl gpu list, try another GPU type with the same VRAM, or create the volume in a data center that has stock for that GPU. aws s3 sync to the network volume stalls or errors. The S3-compatible API handles cp, ls, mv, and rm well, and sync can have trouble past about 10,000 files. Archive small files into a tar first. Also check that --region is the data center ID, that the endpoint URL matches it, and that no old AWS_ACCESS_KEY_ID environment variable is overriding the Runpod S3 API key.

Next steps

Choose a Pod

Size GPU, memory, and storage for a workload.

Load-balancing endpoints

Serve your own HTTP server with autoscaling workers.

Network volumes

Share persistent storage across Pods and endpoints.

Terraform provider

Manage Runpod infrastructure as code.
Last modified on November 14, 2026