What is Runpod?

Runpod is a GPU cloud operated by Runpod Inc., which describes the service as the AI Developer Cloud for experimenting, training, fine-tuning, deploying and scaling AI workloads on one platform. The company's website structured data gives October 31, 2022 as its founding date, and the site lists an address at 329 Bryant St, San Francisco, California. The about page describes a remote-first team spread across the United States, Canada, Europe and India, with a presence in San Francisco, and states that more than one million developers run workloads on the platform. Since June 2025 the company spells its name Runpod; the older RunPod styling is deprecated according to the documentation.

The platform is built around three compute products that share one account and one GPU catalog. Pods are dedicated GPU or CPU container instances for development, training, rendering and long-running jobs. Serverless runs a worker container behind an endpoint that starts workers when requests arrive and scales them back to zero after an idle timeout. Instant Clusters provision several GPU nodes in the same data center, connected by 1600 to 3200 Gbps networking, for distributed training and multi-node inference. Around these sit the Runpod Hub of deployable open-source repositories and Public Endpoints, which expose pre-deployed image, video, audio and text models through a pay-per-use API.

Compute runs in Docker containers. Pods start from official, community or custom templates, or from any image in a compatible registry such as Docker Hub, GitHub Container Registry or Amazon ECR. Pods are offered on two clouds: Secure Cloud, which runs in T3/T4 data centers, and Community Cloud, which connects vetted individual compute providers to users through a peer-to-peer system at lower prices. The homepage lists more than 30 GPU SKUs, from RTX 4090 cards to B200 accelerators, across 31 global regions; the GPU reference also includes the AMD Instinct MI300X. The documented Pod limits are that Docker Compose cannot be used, only TCP and HTTP connections are supported (no UDP), and Windows is not supported as a Pod operating system.

Pricing is usage based. The pricing page publishes hourly rates per GPU type for Pods, Serverless workers and Instant Clusters, with billing per second, and directs reserved capacity and contract pricing to the enterprise sales team. Accounts work on prepaid credits that can be topped up by credit card or cryptocurrency, with optional auto-pay and post-paid billing described in the billing documentation. There is no charge for data ingress or egress, and a default spend limit of $80 per hour applies across all resources until support raises it.

Programmatic access is provided by a REST API v2 with an OpenAPI schema, the open-source runpodctl command-line tool, the runpod Python package (which also contains the former Flash app SDK and the rp CLI), JavaScript and Go SDKs for Serverless endpoints, and a Terraform provider that reached version 2.0.0. On security, the compliance page states that Runpod Inc. holds an ISO/IEC 27001:2022 certificate valid from August 27, 2026 to August 26, 2029, has completed SOC 2 Type II and SOC 3 examinations and maintains HIPAA and GDPR programs, with documents available through the Runpod Trust Center. The service itself is proprietary and is not offered for self-hosting.

Inside the application

Runpod screenshots

Explore the interface. Open a screenshot to view it at full size.

View full size ↗

Runpod screenshot 1

Official Runpod documentation screenshot of the Connect tab for a running Pod.

View full size ↗

Serverless endpoint requests

Official documentation screenshot of a Serverless endpoint request tester in the Runpod console.

View full size ↗

Serverless worker logs

Official documentation screenshot of worker logs for a Serverless endpoint, with filters by worker, level and time.

Source: official Runpod project page.

Key capabilities

Pods on Secure Cloud and Community Cloud A Pod is a container with dedicated GPU or CPU resources and full control over software, storage and networking. Secure Cloud runs in T3/T4 data centers; Community Cloud uses vetted individual compute providers at lower rates. The pricing page FAQ lists, for example, the H100 PCIe at $2.89 per hour on Secure Cloud or from $1.99 per hour on Community Cloud, billed per second. On-demand Pods need at least one hour of credit for the selected configuration before they deploy (Pod pricing).
Templates and custom images Pod templates bundle a container image, disk sizes, mount paths, exposed HTTP and TCP ports, environment variables and startup commands. Runpod distinguishes official templates maintained and supported by Runpod, community templates supported only through the community Discord, and private or shared custom templates. Pods can also be launched from any compatible registry image (templates overview).
Pod connection options A running Pod can be reached over SSH through the Runpod proxy, over SSH on an exposed TCP port (which supports SCP and SFTP), through a browser-based web terminal, through JupyterLab or other HTTP services on proxied ports, and from VS Code or Cursor. Every Pod comes with runpodctl and a Pod-scoped API key preinstalled.
Serverless endpoints with handler functions A queue-based Serverless endpoint runs a worker image that calls runpod.serverless.start with a handler function. Requests are queued, assigned to workers and returned through /runsync or polled through /run and /status. Load balancing endpoints instead route HTTP traffic directly to worker servers built with frameworks such as FastAPI or Flask, without a queue.
Serverless scaling and billing Workers are billed from start until they fully stop, rounded up to the nearest second, including cold start time and the idle timeout (5 seconds by default). Flex workers scale to zero; active workers run continuously, with discounts available through sales. Cold starts can be reduced with FlashBoot, cached models or a minimum number of active workers (Serverless pricing).
Worker deployment from Docker or GitHub Worker images can be pushed to Docker Hub or another registry, or Runpod can pull a GitHub repository, build the Dockerfile, store the image in its own container registry and deploy it. Endpoints support rolling releases, logs, metrics, job state tracking, SSH into workers and fitness checks that validate a worker before it accepts traffic.
vLLM workers with an OpenAI-compatible API The worker-vllm image serves large language models on Serverless with PagedAttention and continuous batching. It exposes an OpenAI-compatible API, so clients switch by changing the base URL and API key. It can be deployed from the Hub or customised from the runpod-workers GitHub repository (vLLM overview).
Instant Clusters Multi-node clusters of B200, H200, H100 or A100 GPUs run 2 to 8 nodes (16 to 64 GPUs) in one data center, with 3200 Gbps between nodes (1600 Gbps for A100). One node is primary with NODE_RANK=0, and all nodes receive environment variables for distributed communication. Larger clusters up to 512 GPUs, and reserved clusters on 1 to 12 month terms, go through sales.
Managed Slurm and framework guides Instant Clusters can run as managed Slurm clusters, and the documentation covers PyTorch distributed training, Axolotl fine-tuning and distributed inference with Ray and vLLM. Cluster observability is documented separately (Instant Clusters overview).
Runpod Hub The Hub lists preconfigured open-source repositories that deploy as a Serverless endpoint or a Pod. Publishers add hub.json and tests.json in a .runpod directory, create a GitHub release and submit the repository for review; the Hub builds and tests each release. Creators receive 1% to 7% of compute revenue from deployments, paid monthly as Runpod credits.
Public Endpoints Pre-deployed models for image, video, audio and text generation are called with an API key and no deployment. Pricing is per output, for example $0.02 per megapixel for FLUX.1 [dev] or $0.05 per 1000 characters for Minimax Speech, and failed generations are not charged. An @runpod/ai-sdk-provider package connects them to the Vercel AI SDK.
Storage options Pods have a temporary container disk and a volume disk mounted at /workspace. Network volumes persist independently in one data center, in a standard tier and a high-performance tier, and can be managed through an S3-compatible API. Global volumes (beta) are object-backed and mountable from any supported data center. The pricing page lists network storage at $0.07 per GB per month under 1 TB and $0.05 above 1 TB (storage overview).
Runpod CLI (runpodctl) The open-source CLI manages Pods, Serverless endpoints, templates, network volumes, Hub models, registries, billing and SSH, and transfers files with send and receive. Official install methods include a script (curl -fsSL https://cli.runpod.net | sudo bash) that verifies a SHA-256 checksum, Homebrew (brew install runpod/runpodctl/runpodctl), direct binaries for macOS, Linux and Windows, conda-forge and a Nix flake (runpodctl overview).
Runpod Python SDK and rp CLI pip install runpod (Python 3.10 to 3.14, version 2.0 or later for the app features) installs one package with four parts: decorator-based apps (@app.queue, @app.task, @app.api), a client for existing endpoints, the Serverless worker SDK and an API wrapper for Pods and other resources. rp login stores credentials in ~/.runpod/config.toml (SDK overview).
REST API, JavaScript and Go SDKs The REST API v2 at https://api.runpod.io/v2 covers Pods, Serverless, templates, network volumes, registry credentials, the GPU and data center catalog and billing, with per-minute, hourly and daily rate limits reported in RateLimit headers. Endpoint SDKs exist for JavaScript (npm install runpod-sdk) and Go (github.com/runpod/go-sdk) (API v2 reference).
Terraform provider and integrations The Terraform provider 2.0.0 requires Terraform 1.6 or later and manages Pods, Serverless endpoints, templates, network and global volumes, Instant Clusters and registry credentials as code; 2.0.0 is a breaking release from 1.x. The integrations section also documents dstack, SkyPilot, Transformer Lab and Mods (Terraform guide).
Organizations and billing controls Organizations add roles, custom roles, groups, resource tagging and organization billing, and cost centers split spending. Billing runs every 5 minutes from prepaid credit; when the balance reaches $0, Pods stop, and Pods without a network volume are terminated with their data. Low balance email alerts and card auto-pay are available.
Security and compliance documents Pods and workers run in containers isolated from other tenants, and the terms of service prohibit hosts from inspecting customer data. GDPR measures apply to data processed in European data center regions. The ISO/IEC 27001:2022 certificate, SOC 2 Type II, SOC 3, HIPAA and GDPR materials and the SOC 2 Bridge Letter 2026 are listed in the Runpod Trust Center, some behind approved access (security and compliance reference).

Where Runpod fits

Serving a model as an autoscaling API

The documented Serverless workflow is to write a handler function, test it locally with the Runpod SDK, package it with a Dockerfile, push the image or connect a GitHub repository, and attach it to an endpoint. Workers start on demand, process queued jobs and scale down after the idle timeout. Logs, metrics, request history and worker status are shown per endpoint in the console, and endpoint settings control GPU types, worker counts, execution timeouts and FlashBoot.

Hosting an open-weight LLM behind an OpenAI-style API

Runpod documents deploying the vLLM worker from the Hub or from the runpod-workers/worker-vllm repository, with the model either cached by the platform or baked into a custom image. Environment variables map to vllm serve flags. Clients that already use the OpenAI API point their base URL and key at the endpoint.

Interactive development and training on a GPU Pod

A developer picks a GPU type and cloud, starts from a template such as the official PyTorch image, and connects with SSH, JupyterLab, the web terminal or VS Code and Cursor. Working files and checkpoints live on the volume disk or a network volume, which is the storage that survives stopping or deleting the Pod. Files move with runpodctl send and receive, cloud sync or the S3-compatible API.

Multi-node training and fine-tuning

Instant Clusters provision 2 to 8 nodes in one data center with pre-set environment variables and high-speed interfaces for PyTorch, TensorFlow and Slurm traffic. The documentation provides guides for distributed PyTorch, Axolotl fine-tuning across GPUs, managed Slurm and multi-node inference with Ray and vLLM. Shared storage can be attached, and reserved clusters with longer terms are arranged through sales.

Calling hosted generative models without deployment

Public Endpoints let an application send a request to a pre-deployed model such as FLUX.1, Seedream, WAN, Kling, Minimax Speech or Qwen3 32B with an API key. Short jobs use /runsync; longer ones use /run and poll for the result. A playground in the console shows inputs, output and the per-request price.

Managing GPU infrastructure as code or from agents

Teams can declare Pods, endpoints, templates, volumes and clusters in Terraform with the 2.0.0 provider, script them with the REST API v2 or runpodctl, or define remote functions in Python with the Runpod SDK. Runpod also publishes a skills package and an MCP server so that coding agents such as Claude Code and Cursor can deploy and manage Runpod resources.

Similar listings on iThub: Modal, Together AI, Replicate and Fireworks AI. Runpod Serverless also runs vLLM as a worker image.