Key facts
| Startup fit | Free plan with 2 models and no card, then flat monthly tiers |
| Live endpoints | Chat completions with streaming, function calling, JSON mode and embeddings |
| Coming soon | Audio, images, files and batch endpoints are labelled coming soon |
| Models | 30+ models behind one OpenAI-compatible API |
| Migration | Point the OpenAI SDK at a new base URL and map model names |
| Trial | 14-day full-access trial for higher tiers |
| Residency | Region-locked planes: EU (Frankfurt), GCC (UAE), APAC (Singapore), US (Virginia) |
| Deployment | Plugsky cloud first, then VPC, on-prem or air-gapped when a customer demands it |
TL;DR
- Prototype on the free plan with plugsky-micro and plugsky-lite; no card is required.
- Keep the model layer OpenAI-compatible so you can switch or upgrade without a rewrite.
- Design the OCR and transcription stage as an adapter — those endpoints are still coming soon.
- Use JSON mode for structured output and embeddings for retrieval from day one.
- Flat monthly plans replace per-token anxiety when real users arrive.
How it works, step by step
- Choose a narrow multimodal use case — receipt extraction, document Q&A or screenshot analysis — and write the output schema before writing code.
- Create a free account, generate an API key from the dashboard, and store it in environment variables rather than in the client app.
- Wrap OCR or speech in an adapter that returns text, so you can swap engines without touching the reasoning code.
- Call chat completions with JSON mode for structured fields and the embeddings API for retrieval; keep prompts versioned in the repo.
- Build a small evaluation set from real examples and measure before and after every prompt change.
- When usage grows, move to a paid plan or the 14-day full-access trial and route routine traffic to plugsky-micro or plugsky-lite.
Original data
Try it yourself
Open the LLM cost calculator →
The fastest path from idea to demo
Startups do not need a platform team to ship multimodal AI. The minimum viable pipeline is three pieces: an extraction step that turns files, images or audio into text, a reasoning step that produces structured output, and a retrieval step that grounds answers in your data. Plugsky covers the last two on live endpoints — chat completions with JSON mode, plus embeddings — and the free plan gives you two models to build against with no card.
Because the API is OpenAI-compatible, any tutorial, SDK or agent framework that already works with OpenAI works here after a base URL change. That is the fastest possible start for a small team.
An architecture you will not have to rewrite
Two design choices prevent a rewrite later. First, keep extraction behind an interface: today you might call an OCR library, tomorrow a hosted vision model. Plugsky's audio, images and files endpoints are still coming soon, so hard-coding them now would block you; an adapter lets you adopt them when they ship.
Second, keep every model call OpenAI-compatible and configurable by name. With 30+ models behind one endpoint, you can route classification to plugsky-micro, retrieval embeddings to a dedicated embedding model, and hard reasoning to a larger tier without changing application code or prompts more than a model string.
Cost control for a pre-seed budget
Per-token billing is hard to forecast when user behaviour is unknown. Flat monthly self-serve plans with unlimited fair-use usage replace that risk, and the free plan covers development, demos and early design partners. See the live pricing page for current tiers.
Keep unit costs sane by caching repeated extractions, batching embeddings, and trimming prompts rather than switching to weak models for everything. Be honest with investors and design partners about which multimodal endpoints are live and which are roadmap: text, streaming, JSON mode, function calling and embeddings are live today.
Honest comparison
| Concern | Plugsky | Multi-vendor startup stack | Self-hosted models |
|---|---|---|---|
| Time to first demo | Free key and OpenAI-compatible quickstart | Several signups and SDKs | GPU setup and serving |
| Early cost | Free plan with plugsky-micro and plugsky-lite | Free tiers with different limits | Hardware or rented GPUs |
| Model optionality | 30+ models, swap by model name | Re-integrate per vendor | Serve each model yourself |
| Structured output | JSON mode and function calling live | Varies by vendor | Constrained decoding to build |
| Scale-up path | Flat monthly plans plus the 14-day full-access trial | Per-token spend grows with usage | Capacity planning is yours |
Frequently asked questions
Is the free plan really free?
Yes. It includes plugsky-micro and plugsky-lite, two API keys and no credit card. It is aimed at development, prototypes and early validation.
What is live on Plugsky today?
Chat completions with streaming, function calling and JSON mode, plus embeddings, are live. Audio, images, files, batch, moderation, fine-tuning and assistants endpoints are labelled coming soon.
Can we migrate from OpenAI easily?
Yes. The API is OpenAI-compatible: change the base URL and model name, keep your SDK, and run your existing tests before cutting over.
How do we avoid surprise bills as we grow?
Self-serve plans are flat monthly with unlimited fair-use usage and no per-token charges. Monitor usage per key and route cheap steps to smaller models.
Should a startup self-host models instead?
Usually not at the start. Self-hosting adds GPU capacity and MLOps work before product-market fit. Consider on-prem or air-gapped deployment only when a customer contract requires it.
How do we handle documents if file endpoints are coming soon?
Keep a local parsing or OCR adapter that outputs text, and feed that text into live chat completions and embeddings. Swapping in the files endpoint later is then a small change.
Do we need an evaluation suite before launch?
A small one, yes. Twenty to fifty real examples with expected outputs will catch regressions faster than any prompt intuition.