> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aireserve.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Migrate from RunPod

> Move a common secure, on-demand GPU Pod workflow to AI Reserve and understand where the contracts differ.

AI Reserve GPU Instances is a provider-neutral compute contract, not a
wire-compatible RunPod API. The common single-container GPU workflow maps
cleanly, but request fields, IDs, operation polling, and response models change.

## A common request

A secure, on-demand RunPod request conceptually like:

```json theme={"dark"}
{
  "name": "trainer",
  "gpu": { "id": "NVIDIA H100 80GB HBM3", "count": 1 },
  "image": "ghcr.io/acme/trainer:latest",
  "disk": 100,
  "env": { "RUN_NAME": "experiment-42" },
  "ports": ["8000/http"]
}
```

becomes this AI Reserve request:

```json theme={"dark"}
{
  "name": "trainer",
  "accelerator": "H100_80GB",
  "count": 1,
  "image": "ghcr.io/acme/trainer:latest",
  "diskGb": 100,
  "env": { "RUN_NAME": "experiment-42" },
  "ports": [{ "port": 8000, "protocol": "http" }],
  "publicPortsAcknowledged": true,
  "maxHourlyPrice": "4.00"
}
```

The exact RunPod GPU SKU and data center are deliberately absent. AI Reserve
selects eligible secure capacity and returns its own resource ID.

## Call-flow changes

| Direct RunPod pattern | AI Reserve pattern |
| - | - |
| Create a Pod and receive the provider resource | Quote optionally, then launch and receive `202 Accepted` |
| Store a RunPod Pod ID | Store the AI Reserve instance UUID and operation ID |
| Poll provider Pod status | Poll `/v1/gpu/operations/{operationId}`, then fetch the instance |
| Read connections from provider metadata | Call `/v1/gpu/instances/{id}/connections` |
| Retry create according to client policy | Reuse the same `Idempotency-Key` after an ambiguous result |
| Compare provider status enums | Use normalized desired and observed instance states |

The CLI's `--wait` flag handles operation polling. Follow the
[quickstart](/gpu-infrastructure/quickstart) for the complete command sequence.

## Field mapping

| RunPod concept | AI Reserve | Notes |
| - | - | - |
| Exact GPU product | `accelerator` | Canonical family such as `H100_80GB`; exact provider SKU is abstracted |
| GPU count | `count` | Supported from 1 through 16, subject to current stock |
| Data center | `region` | Optional broad region; exact placement remains internal |
| Container image | `image` | Supported |
| Container disk | `diskGb` | Ephemeral root disk |
| Network volume | `volumeId` | Existing volume pins placement to its location |
| New network volume | `storage.persistentGb` | AI Reserve can create it beside the GPU in the same launch |
| Environment | `env` | Write-only values |
| Ports | `{port, protocol}` objects | HTTP requires `publicPortsAcknowledged: true` |
| Registry credential | `registryCredentialId` | Register an AI Reserve credential; provider IDs are not reusable |
| SSH | `sshPublicKey` or `sshKeyIds` | Register with AI Reserve or inject a public key at launch |
| Price policy | `maxHourlyPrice` | Decimal string; bounds the new running commitment |

## What AI Reserve adds

* placement and fallback across mapped provider capacity;
* an optional non-spending quote with a complete price breakdown;
* storage-aware placement and inline persistent-volume creation;
* durable operations and idempotent mutations;
* normalized capacity refusals with a reason and alternatives;
* wallet, quota, and Compute-key policy at one API boundary.

## Provider-specific features not currently normalized

A migration needs redesign—or may not be possible yet—when it depends on:

* Community Cloud or spot/interruptible bids;
* CPU Pods;
* exact GPU SKU, country, data center, or compliance placement;
* minimum host RAM, vCPU, CUDA version, or bandwidth constraints;
* RunPod template IDs, provider-managed Jupyter startup, or Pod locks;
* global networking or private Pod DNS (Instant Clusters are normalized as [multi-node clusters](/gpu-infrastructure/clusters); cluster templates and rename are not);
* local persistent Pod disks or high-performance network-volume tiers;
* in-place Pod updates or a normalized restart endpoint;
* provider runtime metrics or complete launch-configuration read-back.

The normalized API accepts a deliberately smaller set of portable controls. It
does not currently offer a `providerOptions.runpod` escape hatch.

## Storage differences

Both products preserve an independent network volume after compute termination.
AI Reserve additionally places new storage with the GPU and exposes its
post-termination rate in the instance quote. It does not normalize RunPod's
exact data-center selection, volume tiers, or volume rename. See [Storage and
persistence](/gpu-infrastructure/storage) for attachment, billing, teardown,
and the transitional grow flow.

## Migration checklist

* [ ] Map each required RunPod GPU SKU to an AI Reserve accelerator family.
* [ ] Remove exact provider and data-center dependencies, or record them as blockers.
* [ ] Replace create-response assumptions with operation polling.
* [ ] Persist AI Reserve instance and operation IDs instead of RunPod IDs.
* [ ] Add idempotency keys to every mutation.
* [ ] Convert ports and decimal price fields to the normalized shapes.
* [ ] Register SSH keys and registry credentials in AI Reserve.
* [ ] Rework status comparisons and connection discovery.
* [ ] Confirm storage teardown explicitly deletes volumes when intended.
* [ ] Test one paid instance end to end before migrating automation.

For the provider-shaped compatibility API, see [GPU Compute](/capabilities/gpu-compute).
New integrations should use GPU Instances.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.