Key facts
| Free tier | Free plan with 2 free AI models (plugsky-micro, plugsky-lite), no card |
| Evaluation | 14-day full-access trial for testing larger models on real workloads |
| Pricing model | Flat monthly self-serve plans; no per-token billing on self-serve |
| API surface | OpenAI-compatible /v1/chat/completions; use any existing SDK |
| Models | 30+ models behind one API, from small to frontier tiers |
| Routing | Model routing sends routine requests to smaller, faster models |
| Retrieval | Embeddings and RAG are live for grounded product features |
| Endpoint roadmap | Audio, images, batch and fine-tuning are coming soon |
TL;DR
- Ship on flat monthly plans instead of watching per-token bills climb.
- Start on the free tier with two models, no credit card required.
- Use the 14-day full-access trial to test frontier models before committing.
- Keep the API layer thin so switching models is configuration, not a rewrite.
- Route easy requests to small models and save frontier calls for hard ones.
How it works, step by step
- Pick the single feature where AI changes user-visible outcomes, such as search, drafting or extraction.
- Prototype on the free plan with plugsky-micro or plugsky-lite before touching bigger models.
- Wrap every model call in one service layer so model names and prompts live in configuration.
- Use the 14-day full-access trial to benchmark a frontier model against your real task.
- Add routing: small models for classification and summaries, larger models for reasoning.
- Ground answers with embeddings over your own data instead of stuffing context.
- Review usage per feature monthly and move plans only when a limit is actually near.
Original data
Try it yourself
Open the LLM cost calculator →
What to build versus buy in year one
In the first year, your differentiation is the product, not the model. Buying inference as an API avoids GPU procurement, serving frameworks, autoscaling and on-call rotations, none of which customers pay you for. What you should build is the layer that makes the model useful to your users: prompts, retrieval, schemas, evaluation and UX.
That split also keeps you portable. If everything proprietary lives in your service layer, changing model or provider later is a configuration change.
From free tier to paid plan
The free plan includes two models with no card, which is enough to validate an idea and run early demos. When quality demands a larger model, the 14-day full-access trial lets you test it against real traffic patterns. After that, self-serve plans are flat monthly with fair-use usage, so a growth spike does not turn into a billing surprise. Watch the live pricing page for current plan details rather than budgeting from old screenshots.
Architecture that survives scale
Keep one thin client module: base URL, key, model alias, timeout and retry. Add routing per task type rather than hard-coding model names throughout the app. Store embeddings in your own database so retrieval costs and data stay under your control, and cache deterministic responses where the same input recurs.
These choices are cheap at seed stage and expensive to retrofit later.
What to measure
Track cost per active user, latency at the ninety-fifth percentile, fallback rate and task success on a small labelled set. If cost per user stays flat while engagement grows, the architecture is working. If not, route more traffic to smaller models before adding headcount or infrastructure.
Honest comparison
| Capability | Plugsky | Per-token API | Self-hosted GPUs |
|---|---|---|---|
| Upfront cost | Free tier plus flat monthly plans | Low, then variable | Hardware and setup spend |
| Cost predictability | Flat monthly self-serve plans | Scales with traffic | Fixed capacity, variable utilization |
| Engineering time | API integration only | API integration only | Serving, scaling, on-call |
| Model access | 30+ models behind one API | Usually one vendor catalogue | Only what you can host |
| Retrieval | Embeddings and RAG are live | Varies | You assemble the stack |
| Scale-up path | Change plan, keep code | Watch usage | Buy and rack hardware |
Frequently asked questions
Is there really a free tier?
Yes. The free plan includes two free AI models (plugsky-micro and plugsky-lite) with no credit card required, which is enough to prototype and demo.
How does the trial work?
The 14-day full-access trial opens up larger models so you can benchmark them on real workloads before choosing a paid plan.
How do we avoid a surprise bill?
Self-serve plans are flat monthly with fair-use usage and no per-token billing, so traffic growth does not change the bill. See the live pricing page for current plans.
Should we self-host to save money?
Usually not at seed stage. The engineering and capacity costs of self-hosting usually exceed API spend until volume is high and stable. Revisit when that changes.
Can we switch models later?
Yes. Keep model names in configuration and use the OpenAI-compatible surface, so changing model or provider is a config change rather than a rewrite.
What should we build in-house?
Prompts, retrieval, output schemas, evaluation sets and the user experience. Those encode your product advantage; inference does not.
Which capabilities are live today?
Chat, streaming, JSON mode, function calling, embeddings, RAG and agents are live. Audio, images, moderation, files, batch, assistants, responses and fine-tuning are coming soon.