Modal vs DeepInfra (2026): $3.95/hr GPU Seconds vs $0.10/M Per-Token, and the Break-Even

Who Wins Per Workload

The choice is not which platform is "better" but which shape of workload you have. Read down the left column to your case.

Quick Comparison

Modal sells GPU seconds; DeepInfra sells tokens; Morph sells the coding-agent inner loop.

What Each One Is

Modal is infrastructure; DeepInfra is a product built on infrastructure.

Modal: serverless compute for any GPU workload

Modal lets Python developers deploy inference endpoints, run large-scale batch jobs, fine-tune open models, and execute secure agent sandboxes using function decorators, with no YAML, Kubernetes, or cluster management. It bills per second of active compute and scales to zero when idle. The platform covers the full machine-learning lifecycle in one place: training, inference, batch, and sandboxes.

The catch is that you own the serving code. Modal hands you a GPU and a great developer experience; loading a model, batching requests, and quantizing weights are your job. That is the price of flexibility.

DeepInfra: managed open-model inference

DeepInfra runs a catalog of open models behind one OpenAI-compatible API. You pick a model, send a request, and pay per token. There is no GPU to provision, no serving code to write, and no scaling to manage. It runs on its own US data centers and prices most open models below the per-token rates of Fireworks, Together, and Baseten: DeepSeek V4 Pro is $1.30/$2.60 per M in/out on DeepInfra versus $1.74/$3.48 on Fireworks and $2.10/$4.40 on Together.

DeepInfra also offers dedicated GPU clusters (DeepCluster) and private deployments for teams that need a specific model isolated, but the default product is the shared per-token endpoint.

Pricing: Per Second vs Per Token

The two pricing models are not directly comparable, which is the whole point.

Modal: per-second GPU rates

CPU bills at $0.0000131 per core-second and memory at $0.00000222 per GiB-second, on top of GPU. The Starter plan is $0 with $30 in monthly credits and 10 GPU concurrency. The Team plan is $250/mo with $100 credits and 50 GPU concurrency. Enterprise is custom.

DeepInfra: per-token model rates

DeepInfra also sells dedicated GPUs by the hour with minute-level granularity: A100 80GB at about $0.89, H100 at about $1.79, H200 at about $2.19, B200 at about $2.79, and B300 at about $4.20. Those dedicated rates undercut Modal's, but you are renting a fixed GPU rather than scaling to zero, so the right choice depends on utilization.

DeepInfra vs Other Per-Token APIs

DeepInfra is one of several per-token open-model APIs. If you are choosing where to call a model rather than whether to rent a GPU, the comparison that matters is DeepInfra against Fireworks, Together, Baseten, and Novita. On the popular open models DeepInfra is consistently the cheapest of the managed APIs.

On dedicated GPUs by the hour, DeepInfra also undercuts the field: H100 80GB at $1.79/hr versus Modal at about $3.95/hr, Replicate at $5.49/hr, Together at $6.49/hr, Baseten at $6.50/hr, and Fireworks at $7.00/hr. B200 180GB is $2.79/hr on DeepInfra versus about $6.25/hr on Modal and $9.98 to $11.95/hr elsewhere.

The Best Place to Run DeepSeek: 16-Bit Activations

Price is not the only axis. Most serverless providers, including DeepInfra, quantize activations to fp8 to cut serving cost. That lowers the per-token price but moves outputs away from the reference weights, so a quantized DeepSeek does not return exactly what the full-precision model would.

Morph Open Source Models serve DeepSeek with 16-bit (bf16) activations and no fp8 or int8 quantization. Responses match the reference weights, which makes Morph the best place to run DeepSeek when output fidelity matters. For coding agents specifically, Morph adds codegen-tuned speculative decoding plus custom low-level inference kernels, so it is the fastest and highest-quality option for code generation, not a general-purpose menu.

See Morph Open Source Models and pricing.

Cost on a Real Workload

Cold Starts & Autoscaling

Modal engineered cold starts as a feature; DeepInfra hides them behind a warm pool.

Modal containers boot in about 1 second on its custom container stack, and memory snapshotting captures a container's memory state at user-controlled points so it can be reused across boots, cutting the cold-start penalty for large models that would otherwise reload weights and recompile. Functions scale to zero when idle, with a default idle window of 60 seconds via scaledown_window (configurable from 2 seconds to 20 minutes). min_containers keeps warm capacity and buffer_containers over-provisions during spikes. This is what makes scale-to-zero usable: you stop paying for idle GPUs without punishing the next user with a long wait.

DeepInfra does not expose cold starts to you at all. It keeps models warm across many tenants and reports sub-second time-to-first-token, as low as 0.35s on top models, with top models reaching 200 to 317 tokens per second output. You never provision capacity; DeepInfra autoscales behind the API. The tradeoff is that you cannot tune the serving stack, because it is not yours, and DeepInfra quantizes activations to fp8 on many models to hit those rates.

Neither is built for the coding-agent apply loop; if applying model-generated code edits is the bottleneck, that is a different tool (Morph Fast Apply, ~10,500 tok/s, with published benchmarks).

Features & Differentiators

Modal's differentiators are about owning compute; DeepInfra's are about a tuned serving stack you do not have to build.

DeepInfra's serving stack keeps models warm and uses fp8 quantization on many models to reach 200 to 317 tok/s. Function calling, JSON mode, and structured output ship by default, so a tool-using agent works out of the box. On Modal you get all of that only if you build it, which is exactly the point: it is a platform, not a product.

Modal's sandboxes are the standout. They are gVisor-isolated containers that run untrusted code from an LLM or user and return stdout, stderr, and exit codes. For agents that execute generated code, that is a real capability DeepInfra has no answer to.

Compliance & Deployment

Both clear the standard enterprise bars; DeepInfra publishes the longer certification list.

Modal offers SOC 2 from the Starter tier and HIPAA compatibility plus audit logs on Enterprise. DeepInfra is SOC 2 and ISO 27001 certified, with technical and organizational measures for GDPR and HIPAA compliance, and a zero-retention policy: prompts and completions are deleted from disk and memory after a short retention period, with only metadata (request ID, cost, sampling parameters) logged. The one exception is Google models, where Google logs prompts and responses for abuse detection. Both run on US data centers.

DeepInfra limits accounts to 200 concurrent requests by default, with postpaid billing (card or pre-pay), monthly invoices, and mid-month invoicing at usage-tier thresholds of $20, $100, $500, $2,000, and $10,000. There is no free tier. Modal has no per-token context limit because the context window is a property of whatever model you choose to run, and its Starter plan ships $30/month in free credits.

When to Use Modal

• Custom or proprietary models. If the model is not in a public catalog, Modal lets you run it on per-second GPUs without standing up Kubernetes.
• Batch and async workloads. Batch transcription, large-scale embeddings, periodic fine-tunes, and workflows are first-class on Modal and awkward on a token API.
• Agent sandboxes. gVisor-isolated containers run untrusted generated code and return stdout, stderr, and exit codes. This is the cleanest sandbox primitive of the two.
• Spiky traffic with scale-to-zero. Snapshot cold starts near 2 seconds make scaling down to zero practical, so you stop paying for idle GPUs between bursts.
• You want to own the serving stack. Quantization, batching, and routing are yours to tune, which matters when you have squeezed everything out of a managed API.

When to Use DeepInfra

• Drop-in open-model API. Llama, DeepSeek, Qwen, and more behind one OpenAI-compatible endpoint. Swap a base URL and you are running.
• Cost-sensitive token workloads. Llama 3.3 70B Turbo at $0.10 input and $0.32 output per million tokens, with shared GPUs amortizing cost across tenants.
• Tool-using agents out of the box. Function calling, JSON mode, and structured output ship by default, so no serving code is required.
• Regulated industries. SOC 2 and ISO 27001 certified, with GDPR and HIPAA measures and a zero-retention policy on inference (metadata only, except Google models).
• You never want to touch a GPU. No provisioning, no scaling, no serving stack. DeepInfra handles all of it behind the API.

One caveat for DeepSeek users: DeepInfra quantizes activations to fp8 on many models to hit its rates. If you need outputs that match the reference weights, Morph Open Source Models serve DeepSeek with unquantized 16-bit (bf16) activations, and morph-dsv4flash (DeepSeek V4 Flash) is $0.139 input and $0.278 output per 1M tokens.

Frequently Asked Questions

What is the difference between Modal and DeepInfra?

Modal is a serverless compute platform: you write Python, deploy a function, and pay per second of GPU time (about $3.95/hr for an H100 as of June 2026), bringing your own model and serving code. DeepInfra is a managed inference API: you call open models like Llama 3.3 70B or DeepSeek V4 over an OpenAI-compatible endpoint and pay per token (Llama 3.3 70B Turbo is $0.10 input and $0.32 output per million tokens). Modal gives you control; DeepInfra gives you a frontier open model with no infrastructure.

Is Modal or DeepInfra cheaper for LLM inference?

For a standard open model at high utilization, DeepInfra usually wins because you pay only for tokens and it packs many users onto each GPU. Modal can be cheaper for steady high-throughput on a model you control, or for workloads that are not token-shaped such as batch jobs, fine-tuning, and sandboxes. The crossover is your utilization, not the list price.

How fast are Modal cold starts?

Modal containers boot in about 1 second on its custom container stack. Memory snapshotting captures a container's memory state at user-controlled points so it can be reused across boots, which cuts the cold-start penalty for large models that would otherwise reload weights and recompile. Functions scale to zero with a default idle window of 60 seconds (configurable 2 seconds to 20 minutes), so scale-to-zero stays practical.

Does DeepInfra support function calling and JSON mode?

Yes. DeepInfra is OpenAI-compatible and supports streaming, function calling, JSON mode, and structured output, with time-to-first-token as low as 0.35 seconds and 200 to 317 tokens per second output on top models. It uses fp8 quantization on many models to hit those rates, and supports LoRA adapters and dedicated GPU clusters for private deployments.

Can I run a model that isn't in DeepInfra's catalog?

Not on the shared per-token API. DeepInfra serves a fixed catalog of open models (Llama, DeepSeek, Qwen, and similar). For a proprietary model, a custom architecture, a non-standard quantization, or a non-LLM workload like batch transcription or embeddings at scale, you need Modal, where you bring the weights and the serving engine and pay per second of GPU compute. DeepInfra's dedicated GPU clusters can host a private model but still run DeepInfra's serving stack, not yours; Modal is the option when you must own the engine itself.

Where is the best place to run DeepSeek for output fidelity?

Most serverless APIs, DeepInfra included, quantize activations to fp8 to cut serving cost, which moves outputs away from the reference weights. Morph Open Source Models serve DeepSeek with unquantized 16-bit (bf16) activations, so responses match the reference weights, and add codegen-tuned speculative decoding plus custom inference kernels for code generation. morph-dsv4flash (DeepSeek V4 Flash) is $0.139 input and $0.278 output per 1M tokens.

Is DeepInfra cheaper than Fireworks or Together?

On the popular open models, yes. DeepSeek V4 Pro is $1.30/$2.60 per M in/out on DeepInfra versus $1.74/$3.48 on Fireworks and $2.10/$4.40 on Together. Kimi K2.6 is $0.75/$3.50 on DeepInfra versus $0.95/$4.00 on Fireworks and $1.20/$4.50 on Together. Its dedicated H100 at $1.79/hr also undercuts Fireworks ($7.00/hr) and Together ($6.49/hr).