Comparison
QuickSilver Pro vs Modal
Modal isn't an LLM API the way QuickSilver Pro is — it's serverless GPU compute. You ship Python code that loads a model and serves it, pay per GPU-second, and Modal handles cold starts and scaling. QSP is the opposite trade: you give up the ability to run custom models, and in exchange every call is one HTTP request to a managed OpenAI-compatible endpoint. This page exists for teams comparing both approaches — most projects pick one or run them side-by-side.
At a glance
| Feature | QuickSilver Pro | Modal |
|---|---|---|
| Product shape | Managed inference API | ModalServerless GPU compute |
| What you bring | An API key | ModalPython code + a model |
| Cost shape | Per token | Per GPU-second |
| Custom / finetuned models | No (curated catalog only) | Yes |
| Cold start | None | ModalSeconds (model load) per scale-up |
| DeepSeek / Qwen / Kimi out of the box | Yes | BYO image |
| Setup | Sign up, paste key | Modalmodal CLI + container + GPU plumbing |
Pricing (per million tokens, USD)
Competitor list prices as published by each provider.No check date
| Model | QSP input | QSP output | Modal input | Modal output | vs. list | QSP vs Modal · in / out | |
|---|---|---|---|---|---|---|---|
| DeepSeek V4 Pro (managed) | $0.70 | $2.10 | ~$2/hr H100 | + engineering | depends on traffic | QSP $0.70 / $2.10 | Modal ~$2/hr H100 / + engineering |
| Custom finetuned model | — | — | Pay per GPU-sec | BYO | Modal only | QSP — / — | Modal Pay per GPU-sec / BYO |
| Qwen 3.6-35B (long context) | $0.05 | $0.70 | BYO image | + ops | QSP for managed RAG | QSP $0.05 / $0.70 | Modal BYO image / + ops |
QSP columns come from the live catalog at build time; Modal columns are the rates Modal publishes. No check date is recorded for them.
Migration - two lines
# QSP isn't a drop-in for Modal -- they're different categories.
# But if you're moving Modal-hosted LLM inference behind an
# OpenAI-compatible interface, here's the QSP equivalent:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.quicksilverpro.io/v1",
api_key=os.environ["QSP_KEY"],
)
r = client.chat.completions.create(
model="deepseek-v4-pro", # or whichever LLM your Modal app served
messages=[{"role": "user", "content": "Hi"}],
)The two changed lines are marked.
FAQ
If your workload runs on stock open-source LLMs (DeepSeek, Qwen, Kimi, Llama), QSP costs less and faster to ship: zero ops, OpenAI-compatible, per-token billing. If you need to run a custom-finetuned model, a non-LLM workload (embeddings, transcription), or anything that doesn't fit a chat-completions shape, Modal's serverless GPU is the right tool. Many teams use both: QSP for chat, Modal for custom models.
Same math as NIM self-host. An H100 on Modal at ~$2/hr serves a few hundred tokens/sec; the break-even vs QSP's $2.10/M-output price is roughly sustained >60% GPU utilization. Spiky traffic loses badly: every cold start is wasted GPU-seconds, and Modal's per-second billing means idle scale-up time is paid for.
The weights are open-source (DeepSeek, Qwen, Kimi are MIT / Apache), so yes — you can load them on Modal yourself. The question is whether owning that integration pays for itself: QSP serves V4 Flash at $0.18/M output; matching that on Modal requires sustained utilization above the cross-over point and is the engineering team's full-time job. For most teams, the managed price wins.
QSP has none — it's a managed shared service, models are always warm. Modal's cold-start to a fresh GPU + loaded LLM is in the seconds for small models and longer for 70B+ class. For latency-sensitive workloads (interactive chat, agents), QSP is the safer default.
Start with your own key
Change two lines. Compare current per-token prices before your first call.