vast.ai

Renting a GPU on Vast.ai means adding credit, searching the marketplace for a GPU that matches your model, VRAM, price, and availability needs, then launching an instance through the console, CLI, SDK, or REST API. Vast.ai states you can start with as little as $5, there are no contracts or sales calls, and the sign-up-to-running-workload path takes under five minutes. It fits developers and AI teams who want on-demand GPU capacity without committing to a reserved contract.

What Vast.ai actually is

Vast.ai describes itself as "Agent-Ready AI Infrastructure" and a marketplace where prices are set by supply and demand across 20,000+ GPUs. The site reports 40+ data centers, 68+ GPU types, and 700K+ transactions per month, and says it is SOC 2 certified.

The core idea is that every GPU is provisioned through code. The same API developers use to deploy is the interface AI agents use to procure and optimize compute at scale.

The three-step rental flow

Vast.ai lays out the process as follows:

1. Add credit and get your API key. Start with as little as $5. Grab your API key from the console. No contracts, no sales calls.
2. Search GPUs. Filter by model, VRAM, price, and availability, either through the console or the API.
3. Deploy. Launch instances in seconds and scale up or down programmatically.

Billing is per-second, and pricing is described as real-time and programmatically queryable. You can browse current rates on the pricing page rather than assuming a fixed rate.

Three ways to deploy

Vast.ai offers three deployment models on one platform:

Serverless is the option to consider when you don't want to manage instances and want to pay only for compute time. Clusters matter when a single node isn't enough and you need multi-node networking.

Developer tools and entry points

Vast.ai documents three programmatic interfaces:

• CLI — search, filter, and deploy from your terminal, no Python required:

  curl -fsSL https://vast.ai/install.sh | bash
  

• Python SDK — provisioning in five lines of code:

  pip install vastai
  

• REST API — the interface agents call to provision infrastructure:

  curl -H "Authorization: Bearer $VAST_API_KEY" https://cloud.vast.ai/api/v1/bundles/
  

The REST example shows the pattern: you authenticate with a bearer token and query the bundles endpoint to see what's available before deploying.

What you can run

Vast.ai lists use cases spanning AI/ML frameworks, text generation, image and video generation, AI agents, batch data processing, audio-to-text transcription, fine-tuning, virtual computing, GPU programming, and graphics rendering. It also provides pre-configured templates for popular open-source models, such as Qwen Image 2.1 for text-to-image and image editing, so you can launch a working setup without building the environment yourself.

What to check before you commit

• Price is dynamic. Because prices are set by supply and demand, the rate for a given GPU type can move. Query it rather than relying on a remembered number.
• Minimum entry is low, but not free. The $5 figure is a starting credit amount, not a free tier. Confirm current terms on the pricing page.
• Pick the deployment model first. Full-control instances, serverless endpoints, and multi-node clusters solve different problems; choosing the wrong one adds work later.
• API key handling matters. The REST example passes the key as a bearer token, so treat it as a credential and keep it out of shared code.

Vast.ai offers three deployment types, and the right one depends on how much control you need and how much operations work you want to own. GPU Cloud gives you on-demand instances you manage yourself, Serverless turns models into endpoints with automatic benchmarking and optimization, and Clusters provides dedicated multi-node GPU clusters with InfiniBand networking for large-scale training. All three are provisioned through the same API-native platform, so the choice is mostly about control versus convenience rather than a different product.

The three deployment types at a glance

GPU Cloud: when you need full control

GPU Cloud is the general-purpose option. You get on-demand instances from a pool spanning 40+ data centers and 20,000+ GPUs, and you deploy in seconds via CLI, SDK, or API. Because you control the instance, this is the fit for workloads that don't map cleanly onto a managed endpoint — custom AI/ML framework setups, graphics rendering, GPU programming, or batch data processing where you want to configure the environment yourself.

The tradeoff is that you own the instance lifecycle. If your workload needs a specific CUDA version, a custom container, or a non-standard serving stack, that's an advantage. If you just want to call a model and get predictions, it's unnecessary work.

Serverless: when you want zero-ops inference

Serverless deploys models as endpoints, with automatic benchmarking and optimization across GPU types. It autoscales to zero and you pay only for compute time. Choose this when your goal is inference and you'd rather not manage serving infrastructure, batching, or GPU selection — the platform benchmarks and optimizes across GPU types for you.

The autoscale-to-zero behavior matters for intermittent traffic: if your endpoint sits idle, you aren't paying for an idle GPU. The tradeoff is less control over the exact runtime environment compared with a raw instance.

Clusters: when training needs to span nodes

Clusters provides dedicated multi-node GPU clusters with InfiniBand networking, aimed at large-scale training. The distinguishing feature is the interconnect: InfiniBand is what makes multi-node training practical when gradient synchronization across nodes would otherwise bottleneck on slower networking. If your job fits on a single GPU or a single node, Clusters is more infrastructure than you need — GPU Cloud covers that case.

How to decide

Work backward from the workload:

• Custom environment or non-inference workload (rendering, GPU programming, custom frameworks, batch processing) → GPU Cloud.
• Inference where you don't want to manage serving → Serverless, especially if traffic is bursty and autoscale-to-zero saves idle cost.
• Training that must span multiple nodes with fast interconnect → Clusters.

A useful secondary check is ops ownership. GPU Cloud and Clusters both assume you manage the workload; Serverless assumes you don't. If you're unsure, start with GPU Cloud — it's the most general option and you can move to a more managed or more specialized type once the workload's shape is clear.

Getting started

All three are reached through the same entry points, so trying one doesn't lock you into a separate toolchain:

• CLI: curl -fsSL https://vast.ai/install.sh | bash — search, filter, and deploy from your terminal, no Python required.
• Python SDK: pip install vastai — programmatic provisioning in a few lines.
• REST API: curl -H "Authorization: Bearer $VAST_API_KEY" https://cloud.vast.ai/api/v1/bundles/

Onboarding starts with adding credit and getting an API key from the console; Vast.ai's own guidance is that you can start with as little as $5, with no contracts or sales calls, and go from sign-up to running GPU workloads in under five minutes. From there you search GPUs by model, VRAM, price, and availability, then deploy. Pricing is set by supply and demand across the GPU pool and is programmatically queryable, with per-second billing — check the current pricing page for live rates rather than assuming a fixed number.

Vast.ai exposes three programmatic interfaces for deploying GPUs — a CLI, a Python SDK, and a REST API — plus pre-configured templates for popular open-source models. All three tools target the same underlying GPU inventory, so you can search, filter, and launch from whichever surface fits your workflow. The site states that every GPU on the platform is provisioned through code, and that the same API developers use is the interface AI agents use to procure compute at scale.

The three deployment tools

CLI

The CLI is aimed at terminal-first workflows. According to the site, it lets you search, filter, and deploy from your terminal with no Python required. It installs via a single shell command, after which you can query the GPU inventory and launch instances without leaving the shell.

Python SDK

The SDK wraps the same provisioning capability in Python. The site describes it as "programmatic compute provisioning in five lines of code," installed with pip install vastai. This is the natural choice if your training or inference scripts already live in Python and you want instance lifecycle management inside the same process.

REST API

The REST API is the lowest-level interface and the one the site explicitly frames as the interface agents call to provision infrastructure. It authenticates with a bearer token ($VAST_API_KEY) and, in the documented example, hits the bundles endpoint to retrieve available GPU offers. Use it when you need language-agnostic automation, an agent loop, or integration into a system that isn't Python or shell based.

Pre-configured model templates

Beyond raw instance provisioning, Vast.ai offers templates for popular open-source models that you can launch without building the environment yourself. The site's model library lists entries such as Qwen Image 2.1, described as a compact 7B unified text-to-image and image editing model. These templates are the fastest path if your goal is to run a known model rather than configure a blank GPU instance.

What you need before deploying

• An account with credit. The site states you can start with as little as $5, and that there are no contracts or sales calls.
• An API key. Retrieved from the console; required for the REST API and used by the SDK and CLI for authenticated operations.
• A target GPU profile. You filter by model, VRAM, price, and availability, either through the console or the API.

The site claims the path from sign-up to running a workload takes under five minutes, and that instances launch in seconds and can be scaled up or down programmatically.

Choosing between them

• If you want to poke at the inventory interactively, start with the CLI.
• If you're scripting a pipeline in Python, use the SDK.
• If you're building an agent or a non-Python service, call the REST API.
• If you just want a specific open-source model running, start from a template instead of a bare instance.

These aren't mutually exclusive — the same account and API key work across all three, so you can prototype in the CLI and move the same operations into the SDK or API later.

Vast.ai is a GPU cloud rental platform where you rent high-performance GPUs by the second from a global pool of providers. You use it when you need on-demand compute for AI, machine learning, deep learning, or rendering work but don't want to buy hardware or commit to a long-term contract. According to the site, the marketplace spans 20,000+ GPUs across 40+ data centers and 68+ GPU types, with prices set by supply and demand and provisioned entirely through code.

How the platform is structured

Vast.ai describes itself as "agent-ready AI infrastructure" — an infrastructure layer where AI agents can autonomously design, procure, and optimize their own compute. In practice, that means every GPU is provisioned through an API rather than a manual sales process.

The key characteristics:

• Real-time pricing. Prices are set by supply and demand across the GPU pool and are programmatically queryable, so you can filter by price before committing.
• Per-second billing. You pay for compute time rather than reserved blocks.
• API-native provisioning. The same interface developers use to deploy is the one agents use to procure at scale.
• SOC 2 certified, per the site's own claim.

Three ways to deploy

The platform offers three deployment models, each aimed at a different level of control:

If you want to manage the machine yourself, GPU Cloud is the entry point. If you'd rather not manage infrastructure at all, Serverless handles scaling and optimization for you. Clusters exist specifically for multi-node training jobs that need fast interconnects.

What you can run on it

The site lists these workload categories:

• AI/ML frameworks
• AI text generation
• AI image and video generation
• AI agents
• Batch data processing
• Audio-to-text transcription
• AI fine-tuning
• Virtual computing
• GPU programming
• Graphics rendering

Pre-configured templates are available for popular open-source models, so you can launch a ready-made environment instead of building one from scratch. One example on the site is Qwen Image 2.1, described as a compact 7B unified text-to-image and image editing model.

How to get started

The site outlines a three-step flow that it says takes under five minutes from sign-up to running workloads:

1. Add credit and get your API key. You can start with as little as $5, and the site states there are no contracts or sales calls. The API key comes from the console.
2. Search GPUs. Filter by model, VRAM, price, and availability through either the console or the API.
3. Deploy. Launch instances in seconds and scale up or down programmatically.

You can drive all of this from three developer interfaces:

CLI — search, filter, and deploy from your terminal, no Python required:

curl -fsSL https://vast.ai/install.sh | bash

Python SDK — programmatic provisioning:

pip install vastai

REST API — the interface agents call to provision infrastructure:

curl -H "Authorization: Bearer $VAST_API_KEY" https://cloud.vast.ai/api/v1/bundles/

The expected result at each step is the same: a running GPU instance you can reach programmatically, with the ability to tear it down and repeat the cycle.

What to check before you commit

• Pricing is dynamic. Because prices are set by supply and demand, the rate you see for a given GPU type can change. Query pricing at deploy time rather than assuming a fixed rate.
• The $5 entry point is a starting credit, not a usage ceiling. How far it goes depends on which GPU you rent and for how long.
• Pick the deployment model before you pick the GPU. Serverless and Clusters have different setup paths than raw GPU Cloud instances, so deciding first avoids rework.
• Verify current specs and availability on the platform. GPU counts, data center locations, and model templates are live marketplace data, not fixed catalog entries.

Vast.ai prices GPU rentals by real-time supply and demand across its GPU pool, and bills by the second. You add credit (starting at as little as $5), get an API key, and launch instances without a contract or sales call. That model fits short, bursty, or experimental workloads where you want to start and stop cheaply — and it means the price you see is a live market rate, not a fixed list price.

Where the price comes from

Vast.ai states that prices are "set by supply and demand across 20,000+ GPUs" and are "transparent" and "programmatically queryable." In practice that means:

• No single fixed rate card. Different hosts offering the same GPU model can list different prices at the same moment.
• Prices move. Because they track supply and demand, the cheapest option for a given GPU type can change between sessions.
• You can query them. Pricing is exposed through the same API used to deploy, so you can filter and compare before committing.

The site's own framing is "Compare. Launch. Exit. Repeat." — the pricing design assumes you shop around rather than lock into one machine.

Billing is per-second

Vast.ai bills per second. Combined with the marketplace pricing above, this has a few practical consequences:

• You pay for the compute time you actually use, so a job that runs for minutes costs proportionally less than one that runs for hours.
• Stopping an instance stops the meter, which makes iterative or interruptible work cheaper than on hourly-billed platforms.
• Because rates vary by host, the same per-second billing can produce different totals depending on which instance you pick.

The site does not publish a per-second rate table in the material available; the rate is whatever the selected GPU is listed at when you deploy.

Getting started costs $5

The documented entry point is small:

1. Add credit and get your API key. Vast.ai says you can "start with as little as $5," with "no contracts, no sales calls." The API key comes from the console.
2. Search GPUs. Filter by model, VRAM, price, and availability — through the console or the API.
3. Deploy. Launch instances in seconds and scale up or down programmatically.

The advertised flow is "from sign-up to running GPU workloads in under five minutes."

What "no contract" means for cost control

There is no contract and no sales call in the documented sign-up path, and instances can be exited and relaunched. For budgeting, that means:

• Your spend is bounded by the credit you add, not by a committed term.
• You can exit an instance and pick a cheaper host later, which is the intended loop ("Compare. Launch. Exit. Repeat.").
• Cost predictability comes from your own usage discipline (stopping instances) rather than from a fixed monthly fee.

Choosing between the three deployment types on cost grounds

Vast.ai offers three ways to deploy, and the billing logic differs by type:

If your workload is intermittent or request-driven, Serverless's scale-to-zero is the model designed to avoid paying for idle time. If you need full control of the machine, GPU Cloud's per-second on-demand billing is the fit. Clusters target sustained large-scale training, where you're paying for dedicated multi-node capacity rather than opportunistic spot-style pricing.

Practical checks before you commit

• Query before deploying. Since pricing is programmatically queryable, pull current listings for your target GPU model and VRAM rather than assuming a rate.
• Confirm the host's rate at launch. The marketplace structure means the cheapest listing can change; the rate that applies is the one on the instance you actually start.
• Watch idle time. Per-second billing rewards stopping instances you aren't using — an idle instance still bills.
• Start small. The $5 minimum lets you test the deploy-and-exit loop before scaling up.

For current rates on specific GPU models, use the pricing page or query the API directly, since the numbers are live and change with supply and demand.