Modal Pricing: GPU Rates and Three Monthly Bills

Modal pricing starts with a $0 Starter subscription and $30 in monthly compute credits, but keeping a small GPU endpoint allocated all month can still cost $452.06 after that credit. Choose its serverless model for workloads that can shut down between bursts; compare a dedicated GPU when paid container hours become steady.

Verified against Modal's pricing page, November 2026, with the live page checked on 4 November. All Modal rates, plan allowances and multipliers below come from that page. The workload durations are explicit assumptions, and the bills are calculations, not deployment benchmarks. Prices are in US dollars.

Modal Pricing at a Glance

Starter is the economical default until a workspace limit or required feature pushes you to Team. Modal is a serverless compute platform: you supply a containerized Python application, and it scales the running containers with demand. A container is the running environment holding your code and its resources.

These are the public plans as verified in November 2026. Compute above the included allowance is additional to the subscription.

Starter allows 200 deployed apps, 5 deployed cron jobs and 1 day of log retention. A cron job runs on a schedule. For a builder running one nightly batch and a few inference endpoints, those limits may be sufficient. Ten concurrent GPUs means simultaneous capacity, not a monthly allowance of ten GPU-hours.

Team raises deployed apps to 1,000, log retention to 30 days, and scheduled jobs to unlimited. It includes custom domains, a static IP proxy, environment-level budgets, role-based access control and rollbacks covering 3 versions. The upgrade makes sense when, for example, a fourth workspace member needs access or production troubleshooting needs logs that survive longer than a day.

Enterprise also lists 1,000 deployed apps, with custom log retention and rollback terms. It adds audit logs, single sign-on, HIPAA compatibility, private Slack support and embedded machine-learning engineering services. Volume discounts and capacity limits require a quote; there is no public Enterprise monthly credit amount to insert into an estimate.

All plans list real-time metrics, collaboration, unlimited secrets, custom images, instant deploys, distributed queues and dictionaries, and SOC 2 compliance. Starter and Team list community Slack support. Enterprise is the tier shown with marketplace committed-spend support for AWS and GCP. Those are purchasing arrangements, distinct from transferring general cloud credits.

Team does not pay for itself through the larger compute credit alone. Let U be monthly eligible compute charges before credits:

• Starter compute bill = max($0, U − $30).
• Team compute bill plus subscription = $250 + max($0, U − $100).

Once U reaches $100, Team costs $180 more than Starter for the same base-rate compute: $250 − ($100 − $30) = $180. Below that point, Team still costs more. Choose it for access, controls or capacity. Extra included egress can also affect the overall comparison for a transfer-heavy workload.

Modal GPU Pricing: Every Published Per-Second Rate

The GPU line is only one component of a container's cost. Add physical CPU cores and system memory separately; GPU memory included in the accelerator's name does not replace the container's RAM charge.

The complete standard GPU list on the checked page is:

• Nvidia B300: $0.001972 per GPU-second.
• Nvidia B200: $0.001736 per GPU-second.
• Nvidia H200 SXM: $0.001261 per GPU-second.
• Nvidia H100 SXM5: $0.001097 per GPU-second.
• Nvidia RTX PRO 6000: $0.000842 per GPU-second.
• Nvidia A100, 80 GB: $0.000694 per GPU-second.
• Nvidia A100, 40 GB: $0.000583 per GPU-second.
• Nvidia L40S: $0.000542 per GPU-second.
• Nvidia A10: $0.000306 per GPU-second.
• Nvidia L4: $0.000222 per GPU-second.
• Nvidia T4: $0.000164 per GPU-second.

For multiple GPUs in a container, multiply the chosen GPU rate by the GPU count, then add that container's CPU and memory charges. Do not multiply the whole container bill by the GPU count unless you are also creating that many separate CPU and RAM allocations.

Modal H100 Pricing

The H100 SXM5 rate converts to $3.9492 per GPU-hour: $0.001097 × 3,600. That is the GPU component before CPU, memory, applicable multipliers and plan credits. An hourly conversion is useful for comparing quotes; Modal still meters by the second.

A faster accelerator earns its higher rate only if it reduces the billed time needed for your job enough. Compare cost per completed request or training run at the same output quality and latency requirement. A smaller price per GPU-hour does not establish a smaller bill per outcome.

CPU and Memory Are Additional

Standard CPU costs $0.0000131 per physical-core-second. One physical core equals 2 vCPUs in the terminology Modal uses to compare AWS and GCP. The minimum request is 0.125 physical cores per container.

System memory costs $0.00000222 per GiB-second, with a minimum request of 128 MiB per container. GiB and MiB are binary memory units; keep those units when entering the allocation into your estimate.

For both CPU and memory, billing uses whichever is higher: what you request or what you use. Requesting a large allocation creates a billing floor even if the workload consumes less. Conversely, an application that bursts above the request can cost more than a budget based only on that request.

What Counts Toward a Monthly Bill

Count the container's paid lifetime, including loading and waiting. Modal bills application load time, time processing inputs and the default 60 seconds it keeps a container alive after the last input. That timeout is configurable. Compute charges stop after the application scales down to zero containers.

This matters for an inference API with quiet gaps. Multiplying request count by model execution time omits initialization and the warm tail. If another request arrives while the container remains open, do not automatically add a separate full startup and tail to that request; estimate the actual container lifecycle.

For a constant allocation at standard rates:

Compute cost = billed seconds × (GPU count × GPU rate + physical cores × CPU rate + GiB × memory rate).

Sum that expression across containers. Parallel replicas each contribute their own resource time, even if they run during the same wall-clock minute. For varying CPU or RAM usage, apply the higher-of-request-or-usage rule over time instead of treating the lowest allocation as fixed.

Then calculate subscription + max($0, eligible compute − included compute credit) + charges outside that allowance. Apply the workspace's credit once to its combined eligible usage, not once to every function or GPU.

Modal Sandbox Pricing

Sandboxes use non-preemptible CPU and memory pricing, meaning those resources are not subject to the default Function interruption model. The page explicitly lists:

• CPU: $0.00003942 per physical-core-second.
• Memory: $0.00000667 per GiB-second.
• GPU: the standard GPU rates above.

Modal describes the non-preemptible CPU and memory premium as 3×. Use the explicit Sandbox prices in a budget: they differ slightly from multiplying the displayed, rounded standard decimals by three. Do not triple the GPU rate just because the workload is a Sandbox; its GPU line points to standard pricing.

Region and Execution Multipliers

Selecting a region carries 1.15× to 1.75× base prices, according to the plan comparison. The same comparison lists non-preemptible execution at 3×, and the FAQ specifies that premium for CPU and memory.

The pricing page does not give a complete matrix of how every selection combines across resources. A deployment requiring both fixed placement and non-preemptible execution needs a configuration-specific estimate. The three bills below use standard Functions without selected-region premiums, so neither multiplier is silently baked into them.

Three Worked Monthly Bills

The estimated Starter bills are $452.06 for an always-on endpoint, $32.50 for a bursty API and $141.01 for a nightly batch. Each scenario stands alone in its own otherwise-unused workspace and receives its own full monthly credit. Running all three together would mean one shared credit, not three deductions.

Assumptions for every example: a 30-day month, base-rate Functions, no failed or repeated work, no Shared Endpoint token charges, storage and egress within included allowances, and no tax. CPU and memory requests equal the stated allocations, and actual use never exceeds them. Loading and waiting therefore retain those billing floors. Round only the final totals to cents.

A Small Always-On Endpoint: $452.06 on Starter

Assume one T4, 1 physical CPU core and 4 GiB RAM stays allocated for the entire month. The model must fit that configuration. This is a capacity-budget example, not a claim about which model it can serve or how fast it runs.

Paid time = 30 × 24 × 3,600 = 2,592,000 seconds. That total already includes any loading and waiting inside the month.

• GPU: 2,592,000 × $0.000164 = $425.088.
• CPU: 2,592,000 × 1 × $0.0000131 = $33.9552.
• Memory: 2,592,000 × 4 × $0.00000222 = $23.01696.
• Compute subtotal: $425.088 + $33.9552 + $23.01696 = $482.06016.
• Starter: $0 + max($0, $482.06016 − $30) = $452.06.

On Team, the same example is $250 + ($482.06016 − $100) = $632.06.

This is where serverless loses its main billing advantage: capacity that never shuts down has no unpaid gaps. Keeping a worker warm can still be justified by response-time requirements, but budget it as continuous capacity.

A Bursty Inference API: $32.50 on Starter

Assume 100,000 requests, each taking an assumed 2 seconds of processing on one L4, 2 physical cores and 8 GiB RAM. Requests run sequentially within 500 isolated bursts, each using one container. Every burst adds an assumed 10-second application load and the default 60-second warm tail. There are no overlapping replicas.

• Processing: 100,000 × 2 = 200,000 seconds.
• Loading and waiting: 500 × (10 + 60) = 35,000 seconds.
• Total billed time: 200,000 + 35,000 = 235,000 seconds.
• Combined rate: $0.000222 + 2 × $0.0000131 + 8 × $0.00000222 = $0.00026596 per second.
• Compute: 235,000 × $0.00026596 = $62.5006.
• Starter: max($0, $62.5006 − $30) = $32.50.

The compute cost before credit is about $0.625 per 1,000 requests; after the monthly credit, this particular workload is about $0.325 per 1,000. Use the first figure to budget additional requests at the same burst pattern once the free allowance is consumed. Team would cost $250, because this workload fits within its $100 compute allowance.

Ignoring startup and waiting would omit $9.31: 35,000 × $0.00026596. More isolated bursts or more replicas would change that overhead. Concurrent request handling could change processing time too, but its throughput has to be measured rather than assumed from this sequential example.

A Nightly Batch Job: $141.01 on Starter

Assume one A100, 80 GB, 4 physical CPU cores and 16 GiB RAM runs for 2 hours each night. Each run adds an assumed 30-second load and the default 60-second tail, then scales down. This could represent a scheduled inference batch or a fine-tuning job that fits those resources; the duration is an input, not a training-speed claim.

• Billed time: 30 × (2 × 3,600 + 30 + 60) = 218,700 seconds.
• Combined rate: $0.000694 + 4 × $0.0000131 + 16 × $0.00000222 = $0.00078192 per second.
• Compute: 218,700 × $0.00078192 = $171.005904.
• Starter: max($0, $171.005904 − $30) = $141.01.

Before credits, each nightly run costs about $5.70: $171.005904 ÷ 30. On Team, the monthly bill would be $250 + ($171.005904 − $100) = $321.01.

Here the quiet part of the day matters more than the low-looking GPU-second rate. A rental you stop after each job is a valid competing option; comparing only against a rental left running all month would overstate Modal's advantage.

Modal Credits and the Free-Plan Boundary

The monthly allowance can cover a small workload indefinitely under the current plan, but it is not unlimited GPU access. It covers eligible CPU, RAM and GPU compute in Functions and Sandboxes. The pricing page describes Starter and Team as pay-as-you-go, without requiring prepaid compute or tokens.

Modal Free Credits

Starter includes $30 each month. At the always-on example's combined rate of $0.669528 per hour, that pays for about 44.8 billed hours: $30 ÷ $0.669528. That includes the example's CPU and RAM, so it is more useful than dividing by the T4 price alone.

A builder whose occasional experiments remain within that compute allowance, the plan's feature limits, and the separate storage and egress allowances may have no recurring bill. They also need to avoid separately billed Shared Endpoints. A permanently allocated GPU service does not fit that free-use pattern.

The page does not promise that unused monthly credits roll over or state a universal expiry rule for every grant. Budget the allowance month by month and read any grant's own terms. Do not build a future training budget from assumed accumulated credits.

Modal Startup Credits

Early-stage startups can apply for credit grants, but the pricing page does not publish a universal startup award amount. Treat a grant as available only after approval. It is separate from the recurring Starter allowance.

For graduate students, labs and researchers, the page advertises academic grants of up to $10,000. That is an application-based credit program, not a general student percentage discount or a guaranteed award to every student.

General AWS, GCP and Azure credits cannot be applied directly to Modal usage, according to its pricing FAQ. The page separately mentions an AWS Activate partnership for eligible startups and marketplace purchasing against committed spend. Those arrangements do not turn all cloud credits into Modal credit.

No public annual discount is shown for Starter or Team. If an Enterprise or marketplace offer introduces a commitment, evaluate the term and usable capacity alongside the discounted rate. An unused commitment still consumes budget.

Storage, Egress and Charges Outside Compute

Scaling compute to zero does not mean every invoice line is zero. Saved data and outbound transfer have separate rates and included allowances. Keep them outside the compute-credit subtraction.

Modal Volume Pricing

Volumes, Modal's persistent storage, cost $0.09 per GiB-month, with 1 TiB per month included free. Persistent means the data remains available beyond the lifetime of a running container. A nightly job can finish while leaving its model files and outputs stored.

Estimate the storage retained across the billing period. Do not count only the dataset a job reads at one instant; retained checkpoints and outputs contribute to the stored total too.

Network Egress and Shared Endpoints

Network egress, data sent out, costs $0.04 per GiB beyond the plan allowance. The included monthly amounts are 1 TiB on Starter, 10 TiB on Team and 100 TiB on Enterprise. A service returning large generated files can have a different bill from one returning short text even when compute usage is identical.

Shared Endpoints are another billing model: the pricing page says they charge per token from the first request, and the compute allowance does not cover them. The page dates the removal of Starter free Shared Endpoints usage to September 1, 2026. Do not apply the three GPU-second examples to a token-billed endpoint, or assume the $30 credit makes its first requests free.

When Modal Costs More Than a Dedicated GPU

A dedicated GPU becomes cheaper when its total rental cost falls below Modal's paid-time bill after credits. Compare the same workload first, then the billable lifecycle. Hardware bundles, performance and operational responsibilities can differ even when both offers say A100.

Runpod: A Lower Dedicated Rate for Steady A100 Work

Runpod offers dedicated GPU instances called Pods. Its Runpod's pricing page lists an A100 SXM with 80 GB GPU memory on Secure Cloud at $1.79 per hour, with 16 vCPUs and 125 GB RAM. That is a useful cheaper-option quote for steady A100 work; storage is separate.

The Modal A100 configuration in the nightly example costs $2.814912 per paid hour: $0.00078192 × 3,600, including its 4 physical cores and 16 GiB RAM. At 100 paid hours, that is $281.49 before credits, versus $179 for the listed Runpod Pod. The Pod includes more system memory, and these are not identical host configurations or a throughput benchmark.

Now compare a Runpod Pod retained for the whole 720-hour month with Modal that can shut down:

• Continuous Runpod compute: 720 × $1.79 = $1,288.80.
• Modal Starter compute: max($0, paid hours × $2.814912 − $30).
• Break-even: ($1,288.80 + $30) ÷ $2.814912 = 468.5 paid Modal hours.
• Share of the month: 468.5 ÷ 720 ≈ 65.1%.

Above that paid-time threshold, this continuously rented Runpod Pod has the lower compute bill under the stated assumptions. At a full month, the Modal example costs $1,996.74 after credit, compared with $1,288.80 for the Pod before its additional charges. On Team, the compute-plus-subscription crossover comes earlier, at about 404.6 hours: ($1,288.80 − $250 + $100) ÷ $2.814912.

This percentage measures billed container uptime, not the chip's utilization while running. Startup, processing and warm waiting all count. It also assumes the configurations complete the same work in the same time. Measure that assumption, then add each side's storage, transfer and any required operational expense. If the Pod is stopped between jobs, replace the full-month rental cost with its actual paid schedule and retained-storage cost.

The Runpod pricing breakdown explains the Pod-versus-Serverless buying decision. A low Pod rate is not evidence that every Runpod Serverless configuration is cheaper than Modal.

Replicate: Compare What the Endpoint Bills

Replicate, a platform for running hosted and custom models, is the other relevant shortlist when you want model inference through an API. Its Replicate's hardware pricing page lists an A100 80 GB at $0.001400 per second, or $5.04 per hour, bundled with 10 CPU units and 144 GB RAM. At 100 billed hours, that is $504 before other applicable terms, versus the Modal example's $281.49 before credit.

That larger hourly figure is not the complete decision. Replicate says time-priced public models bill processing time; most private models bill setup, idle and active time, with a separate exception for fast-booting fine-tunes. Some models charge by input or output instead of hardware time.

A public endpoint can therefore bill fewer seconds than a custom container with a warm tail. A private endpoint kept online can have the opposite budget shape. Pick the exact model and billing mode before comparing the total. Replicate fits a buyer who wants an available model API; its public catalog price is not a quote for every custom deployment.

For the wider shortlist, use the GPU cloud providers comparison. The deciding criteria remain completed-work cost, acceptable startup delay, runtime control, required capacity and the effort of operating it.

Who Should Choose Modal

Choose Modal when custom Python compute needs to expand for bursts and disappear during quiet periods. The main cost boundary is persistent allocation: a service that must remain warm loses much of the value of scaling to zero. The feature boundary is equally concrete: seats, concurrency, logs and scheduled-job limits can force a subscription upgrade before compute volume does.

For inference, measure a request after inactivity and a representative burst. For fine-tuning or batch work, measure the complete run including loading, output storage and recovery from failure. A long training job also needs an interruption strategy because standard Functions are preemptible by default.

Next week, turn one representative run into a monthly estimate:

1. 1

   Record the resources and lifecycle

   Write down the GPU count, requested and observed CPU and RAM, application load time, useful processing time, replicas and time left warm. Replace the assumed durations in the examples with measured values.

2. 2

   Apply the workspace bill

   Sum eligible compute, apply the monthly credit once, then add the subscription, excess storage, egress and any token-billed usage. Use the exact resource rates for regional or non-preemptible settings.

3. 3

   Compare the same finished work

   Price an alternative that meets the same latency, memory and recovery requirements. Set a workspace budget before expanding traffic; review the first bill against the estimate.

Modal Pricing Questions

Is Modal free?

Starter has no monthly subscription fee and includes $30 of compute each month. Usage beyond that, excess storage or egress, and products outside the compute allowance can still produce charges. Team starts at $250 per month plus compute beyond its included $100.

Free serverless GPU

Modal's Starter allowance can cover occasional GPU work if the combined GPU, CPU and memory charges remain within $30 for the month. It is a limited compute allowance, not an unlimited or continuously allocated free GPU.

Does Modal offer a student discount?

The pricing page advertises academic credit grants of up to $10,000 for graduate students, labs and researchers. It does not list a universal student percentage discount. Grant approval and terms matter.

What is Modal's refund policy?

The current service terms say fees are nonrefundable except as described in section 3.2. They also restrict reducing or canceling service-order commitments. Do not assume unused prepaid or committed spend is refundable; check the agreement attached to your purchase.

Has Modal pricing changed?

The live pricing page specifically dates a Starter Shared Endpoints change to September 1, 2026: token usage is billed from the first request and is outside the monthly compute allowance. This verification does not establish a complete historical series of GPU-rate changes.

Modal Runpod

For the A100 example, a continuously rented Runpod Secure Cloud Pod crosses below Modal Starter's compute cost at about 468.5 billed Modal hours in a 30-day month. That threshold assumes equal execution time and excludes additional charges. A Pod stopped between jobs needs a different calculation.

Modal pricing sandbox

Sandbox CPU is $0.00003942 per physical-core-second and RAM is $0.00000667 per GiB-second. The page describes non-preemptible CPU and memory as a 3× premium and points GPU billing to the standard GPU list.

Get the AI Business Workflow Audit Checklist and the operator newsletter.