Pricing
EnvLoop charges for the compute you hold, at a published list price per meter. The same GPU type has the same price for inference endpoints, training and batch training. See Billing for the balance, holds and what is charged today.
Price list
Price book pb_2026_10_v2 takes effect on 2026-10-17 at 00:00 UTC. All prices are in USD.
| Resource | Meter | Price |
|---|---|---|
| H200 GPU | gpu.H200 | $6.79 per GPU-hour |
| H100 GPU | gpu.H100 | $3.79 per GPU-hour |
| B200 GPU | gpu.B200 | $11.99 per GPU-hour |
| B300 GPU | gpu.B300 | $14.99 per GPU-hour |
| vCPU | cpu.vcpu | $0.072 per vCPU-hour |
| Memory | cpu.mem | $0.024 per GiB-hour |
| Storage | storage.bytes | $0.05 per GB-month, first 50 GB per workspace free (Storage) |
A listed price does not guarantee capacity; availability differs by GPU type. When a resource needs GPUs, EnvLoop searches the GPU provider's current capacity in every country its policy allows, across all variants of each approved GPU type, and allocates the cheapest machine that meets the platform's requirements for GPU memory, driver version, reliability, disk and hourly price. Until such a machine is available the resource waits; that wait comes before allocation and is not billed. A charged endpoint, training session or batch training job on hardware without a list price is rejected with 409 PRICE_MISSING before anything starts; a charged Agent Job sandbox Trial fails with PRICE_MISSING instead.
Until 2026-10-17 00:00 UTC the previous book, pb_2026_10_v1 (effective 2026-10-01), applies: H200 $7.00 and H100 $8.50 per GPU-hour. It also listed storage at $0.018 per GB-month, which was never charged. It has no other meters, so vCPU and memory have no price before 2026-10-17.
Each minute of usage is priced with the book in effect at the start of that minute, so a resource running across a price change pays the old price before it and the new price after it. Charges already recorded are never repriced.
Price change effective 2026-10-29
Price change effective 2026-10-29 at 00:00 UTC. Price book pb_2026_10_v4 raises the H100 price. No other meter changes: H200, B200, B300, vCPU, memory, storage and LLM tokens keep the prices above.
| Resource | Meter | Until 2026-10-29 00:00 UTC | From 2026-10-29 00:00 UTC |
|---|---|---|---|
| H100 GPU | gpu.H100 | $3.79 per GPU-hour | $5.19 per GPU-hour |
The new price applies to every product that meters gpu.H100: inference endpoints, training sessions, batch training jobs and sampling replicas. A minute that starts before 00:00 UTC on 2026-10-29 is charged at $3.79 even if it ends at the switch; the first minute at or after it is charged at $5.19. A resource that runs across the switch pays the old price before it and the new price after it, and charges already recorded are never repriced. Quotes and price lookups follow the same rule: at before the switch returns pb_2026_10_v3, at from the switch on returns pb_2026_10_v4. The holds an endpoint, training session or batch training job takes also use the book in effect when they are taken.
Meters and units
| Meter | Measures | Price unit | Native unit in API responses |
|---|---|---|---|
gpu.<GPU type> | GPUs held × time | GPU-hour | GPU-millisecond |
cpu.vcpu | vCPUs held × time | vCPU-hour | vCPU-millisecond |
cpu.mem | Memory held × time | GiB-hour (1 GiB = 1024 MiB) | MiB-millisecond |
storage.bytes | Stored bytes × time | GB-month (10⁹ bytes × 730 hours) | byte-hour |
GPU usage counts every GPU actually allocated: a training session on 2 nodes with 4 H100 GPUs each meters gpu.H100 × 8. If the provider allocates a different GPU type than the first choice, for example an H200 option filled with H100 GPUs, the allocated type is billed. Each GPU meter covers every variant of its type: H100 SXM, H100 PCIe and H100 NVL are billed as gpu.H100, and H200 and H200 NVL as gpu.H200. Agent Job sandboxes meter their allocated vCPUs and memory, not their average utilization.
How time is billed
- Start. The clock starts when the resource is allocated to you, provided it becomes ready: an endpoint replica reaches READY, a training session or batch training job starts running, or a sandbox starts. Startup time between allocation and ready (the cold start) is included. A resource that fails before becoming ready is not charged.
- Stop. The clock stops at the earliest of: the provider confirming the release; EnvLoop recording the resource as ended without that confirmation, such as a training session reaching a final state; and 5 minutes after you or EnvLoop request the stop. The end of an Agent Job Trial counts as a stop request, so a sandbox kept for a delayed delete is billed for at most 5 more minutes. If the resource is lost, for example its machine disappears, it stops at the last successful health check. An ended resource never accrues more time.
- Minimum. Every billed resource is charged for at least 60 seconds from allocation.
- Precision. Billing is per second of use: time is measured in milliseconds and recorded in one-minute slices aligned to UTC minutes, and it is never rounded up to whole minutes or hours apart from the 60-second minimum. While a charged endpoint, training session or batch training job runs, each completed minute is charged up to its latest health check, so charges appear shortly after each minute ends. A charged sandbox is charged when its Trial ends.
- Amounts. Charges are whole micro-dollars (1 micro-USD = $0.000001). For each resource and meter within one price book, the price of its cumulative usage is rounded half up, and each minute is charged the difference. The minute charges therefore add up exactly to the price of the whole duration, rounded once.
Examples
These examples use synthetic times and the pb_2026_10_v2 prices (the same as pb_2026_10_v3). The H100 examples use the price until 2026-10-29; from then on, replace $3.79 with $5.19 (Price change).
| Case | Billed time | Charge |
|---|---|---|
| Endpoint replica on 1 × H200: allocated 10:00:00, READY 10:06:00, stop requested 10:40:00, release confirmed 10:47:30 | 10:00:00–10:45:00 (cold start included; stop capped at request + 5 minutes): 0.75 GPU-hour | 0.75 × $6.79 = $5.092500 |
| Endpoint replica on 1 × H200 that fails at 10:03:00 before READY | none | $0 |
| Endpoint replica on 1 × H200: allocated 10:00:00, READY 10:00:10, released 10:00:20 | 60-second minimum: 1/60 GPU-hour | $0.1131666… rounded half up = $0.113167 |
| Training session on 2 nodes × 4 H100: allocated 10:00:00, running 10:05:00, released 10:31:15 | 1,875 s × 8 GPUs = 4.166667 GPU-hours | $15.7916666… rounded half up = $15.791667 |
| Agent Job sandbox with 2 vCPUs and 4 GiB for 10 minutes | 0.333333 vCPU-hour and 0.666667 GiB-hour | $0.024000 + $0.016000 = $0.040000 |
These amounts are deducted from the workspace balance; see What is charged today.
LLM tokens
Model calls that your Agent Jobs make through EnvLoop model access are metered per request and priced at the model providers' official list prices, with no markup. These prices are part of price book pb_2026_10_v3, which takes effect on 2026-10-17 at 01:00 UTC (the compute prices above are unchanged); before that, LLM tokens have no price. LLM tokens are deducted from the workspace balance like other usage; see Project LLM usage. Calls made with your own provider key (bring your own key), or to a model endpoint other than EnvLoop's, are not metered.
USD per 1 million tokens:
| Model | Input | Cached input | Cache write (5 minutes) | Cache write (1 hour) | Output |
|---|---|---|---|---|---|
gpt-6-astra | $10.00 | $1.00 | $12.50 | – | $50.00 |
gpt-6-astra, long context | $20.00 | $2.00 | $25.00 | – | $75.00 |
gpt-6-astra, Flex or Batch tier | $5.00 | $0.50 | $6.25 | – | $25.00 |
gpt-6-astra, Fast tier | $20.00 | $2.00 | $25.00 | – | $100.00 |
gpt-6-astra, Ultrafast tier | $60.00 | $6.00 | $75.00 | – | $300.00 |
gpt-6.1-sol | $2.00 | $0.10 | $2.50 | – | $10.00 |
gpt-6.1-sol, long context | $4.00 | $0.20 | $5.00 | – | $15.00 |
gpt-6-sol | $2.00 | $0.20 | $2.50 | – | $10.00 |
gpt-6-sol, long context | $4.00 | $0.40 | $5.00 | – | $15.00 |
gpt-6-luna | $0.10 | $0.01 | $0.125 | – | $0.50 |
gpt-6-luna, long context | $0.20 | $0.02 | $0.25 | – | $0.75 |
gpt-5.6-sol | $4.00 | $0.40 | $5.00 | – | $20.00 |
gpt-5.6-sol, long context | $8.00 | $0.80 | $10.00 | – | $30.00 |
gpt-5.6-terra | $2.00 | $0.20 | $2.50 | – | $12.00 |
gpt-5.6-terra, long context | $4.00 | $0.40 | $5.00 | – | $18.00 |
gpt-5.6-luna | $0.20 | $0.02 | $0.25 | – | $1.20 |
gpt-5.6-luna, long context | $0.40 | $0.04 | $0.50 | – | $1.80 |
gpt-5.4-mini | $0.75 | $0.075 | – | – | $4.50 |
claude-fable-5-1 | $10.00 | $0.25 | $12.50 | $20.00 | $50.00 |
claude-opus-5-5 | $4.00 | $0.20 | $5.00 | $8.00 | $20.00 |
claude-sonnet-5-5 | $2.00 | $0.10 | $2.50 | $4.00 | $10.00 |
claude-haiku-5-5 | $0.10 | $0.01 | $0.125 | $0.20 | $0.50 |
claude-haiku-5-5, long context | $0.50 | $0.05 | $0.625 | $1.00 | $2.50 |
claude-opus-5 | $5.00 | $0.50 | $6.25 | $10.00 | $25.00 |
claude-opus-4-8 | $5.00 | $0.50 | $6.25 | $10.00 | $25.00 |
claude-sonnet-5 | $2.00 | $0.20 | $2.50 | $4.00 | $10.00 |
- Kinds. Each request is split into uncached input, cached input (cache reads), cache writes and output. OpenAI cache writes use the 5-minute column. Reasoning tokens count as output. The meter is
llm.<model><variant>.<kind>, for examplellm.gpt-6-astra.cache_readorllm.gpt-6-astra@long.output. - Long context. When a request's prompt (uncached input + cached input + cache writes) is longer than 272,000 tokens for the
gpt-6andgpt-5.6models, or 100,000 tokens forclaude-haiku-5-5, every token of that request uses the long-context prices. - Service tiers. A non-standard service tier is priced only where the table lists it; Fast mode (also reported as
priority) uses the Fast tier prices. Usage on a model, tier or variant without a list price is shown as unpriced and never charged at a cheaper price. - Names.
gpt-6is billed asgpt-6-astra; provider prefixes and dated version suffixes are ignored. - Amounts. Charges are whole micro-dollars. For each project, model provider, UTC day and meter, the price of the cumulative tokens is rounded half up once, so many small requests add up to the exact price of their total. Example: 12,000 input and 800 output tokens on
gpt-6-astracost 0.012 × $10.00 + 0.0008 × $50.00 = $0.160000.
Storage
Storage is the checkpoints your training sessions and batch training jobs keep. It is charged every hour, from 2026-10-20:
- What counts. Each project's retained checkpoints, by their recorded size. A checkpoint stops counting as soon as you request its deletion or its expiry (TTL) passes, even before the objects are removed. A save that is still uploading does not count yet.
- Free allowance. The first 50 GB of each workspace are free. Above that, the stored bytes are charged at $0.05 per GB-month: 1 GB kept for one hour costs $0.05 / 730 ≈ $0.0000685. A workspace with several projects pays only for the bytes above 50 GB, shared among its projects in proportion to their bytes.
- When. Once each UTC hour ends, that hour is charged at the bytes still retained, counting checkpoints created before the hour ended. Each project's hourly charges are rounded once on their cumulative usage, like the other meters.
- No hold, no stop. Storage takes no hold, and a workspace whose balance falls to zero or below keeps its checkpoints; it is still charged for them. Delete checkpoints you no longer need to stop paying for them.
For example, a workspace keeping 80 GB of checkpoints in one project for a full day pays 30 GB × 24 hours = 720 GB-hours: 720 / 730 × $0.05 = $0.049315.
Sampling outside a training session
Public interactive sampler factories are removed. The rules below describe supported inference-backed sampling and retained usage; use the normal inference API.
Sampling inside a training session runs on that session's own GPUs and is covered by its GPU time. Everything else runs on a sampling replica of your own workspace: a dedicated GPU replica, never shared with other workspaces, billed by GPU time at the same gpu.<GPU type> price as training and endpoints. This covers a sampling client without a training session (base model or checkpoint), sampling after a session has ended, a checkpoint the session's GPUs cannot load (another base model, or an adapter that trains the output layer while that is not yet supported on training GPUs), and envloop:// checkpoints or base models used as the model of the OpenAI-compatible API.
- Hardware.
Qwen/Qwen3.5-4Bsamples on 1 × H100 andQwen/Qwen3.8-27Bon 1 × H200; each long-context variant (:peft:262144) has its own replica on the same hardware. - When it runs. The first request starts the replica, through the supported inference API; the cold start (a few minutes) is billed like an endpoint's, from allocation. All your checkpoints of the same model share the replica. It stops after 10 minutes without requests, and those idle minutes are billed. The next request starts it again.
- Funds. Starting a replica holds funds for 20 minutes of its GPU (an endpoint holds an hour); with too little balance (plus credit) the request is refused with
INSUFFICIENT_BALANCE, and a running replica stops when the balance runs out, like an endpoint. Usage pages list it as Sampling (workspace): it belongs to the workspace, not to one project. Billing ends when the replica is released, at most 5 minutes after it is stopped (the usual stop rule). Example: a 4B replica allocated at 10:00:00 that serves requests until 10:20:00 and is released at 10:30:00 is billed 0.5 GPU-hour × $3.79 = $1.895000.
Look up prices and quotes
Read the price book in effect, with every meter, from the public API. Add at with an ISO 8601 time and time zone to read the book in effect at another time:
curl -H "Authorization: Bearer $ENVLOOP_API_KEY" \
"https://api.envloop.ai/v1/billing/prices?at=2026-10-17T00:00:00Z"
Price a shape before you launch it. meters lists meter:count pairs separated by commas: GPUs for gpu.<GPU type>, vCPUs for cpu.vcpu and MiB for cpu.mem. hours defaults to 1 and must be a whole number of seconds:
curl -H "Authorization: Bearer $ENVLOOP_API_KEY" \
"https://api.envloop.ai/v1/billing/quote?meters=gpu.H100:8&hours=1"
{
"price_book": "pb_2026_10_v2",
"effective_from": "2026-10-17T00:00:00+00:00",
"currency": "USD",
"seconds": 3600,
"lines": [
{"meter": "gpu.H100", "count": 8, "unit": "GPU-hour", "usd_per_unit": "3.790000",
"amount_micro_usd": 30320000, "amount_usd": "30.320000"}
],
"amount_micro_usd": 30320000,
"amount_usd": "30.320000"
}
A one-hour quote for a GPU shape equals the hold an endpoint replica takes before it starts. A training session or batch training job holds 20 minutes of all GPUs on all nodes, priced at its most expensive accepted GPU type until the GPUs are allocated and at the allocated type afterwards. For a sandbox, quote its vCPUs and memory (in MiB) for its timeout plus 5 minutes: a sandbox with 2 vCPUs, 4 GiB and a 600-second timeout holds meters=cpu.vcpu:2,cpu.mem:4096&hours=0.25, which is $0.060000.
Each meters item must be gpu.<GPU type> (1–32 letters, digits or hyphens), cpu.vcpu or cpu.mem, with a positive whole count of at most 7 digits, and each meter may appear once. hours must come to a whole number of seconds, from 1 second to 366 days. Anything else, including storage and other meter names, returns 422 INVALID_QUOTE. A well-formed meter that the selected price book does not list, such as a GPU type without a price, cpu.vcpu with an at time before 2026-10-17, or any meter with an at time before 2026-10-01, returns 409 PRICE_MISSING. An at without a time zone returns 422 INVALID_BILLING_WINDOW. Prices and quotes are available to project members and to project API Keys other than Inference only Keys.