Key facts
| API compatibility | OpenAI-compatible chat, embeddings and function calling |
| Use cases | In-app assistants, document Q&A, support automation, agent workflows |
| Free tier | plugsky-micro and plugsky-lite on the free plan, no card required |
| Trial | 14-day full-access trial for frontier models |
| Pricing model | Flat monthly self-serve plans with unlimited fair-use usage |
| Scale path | Move from shared cloud to VPC, on-prem or air-gapped without code changes |
| Models | 30+ models from free aliases to frontier reasoning |
| Product status | Chat, streaming, JSON mode, function calling, embeddings, RAG and agents are live |
TL;DR
- Choose compatibility first so you never rewrite for a provider switch.
- Ship the first feature on the free plan with no card and no sales call.
- Keep token spend predictable with flat self-serve pricing.
- Use embeddings and RAG so answers reflect your product's data.
- When enterprise buyers ask, move to VPC or on-prem without changing code.
How it works, step by step
- Define one feature that removes real user effort, such as document Q&A or a support assistant.
- Prototype with plugsky-micro or plugsky-lite on the free plan using the OpenAI SDK you already know.
- Add embeddings and retrieval so answers cite your own content instead of model memory.
- Use the 14-day full-access trial to benchmark a frontier model on your hardest real inputs.
- Keep prompts, evals and model versions in the repo so quality changes are deliberate.
- When a customer demands residency or isolation, switch to VPC or on-prem using the same code.
Try it yourself
Open the OpenAI migration checker →
Startup use cases that ship fast
Startups win by shipping one useful feature, not a platform:
- In-app assistant: answer questions about the user's own workspace with citations.
- Document Q&A: let users query uploads, contracts or tickets they already have.
- Support automation: draft replies and route tickets before you hire a support team.
- Agent workflows: chain function calls to automate a repeated back-office process.
All four run on the same compatible endpoint, so the first feature becomes the foundation for the next one.
Keep burn predictable
Per-token billing is hard to forecast when a growth loop spikes usage. Self-serve Plugsky plans are flat monthly with unlimited fair-use usage, so a launch day or a viral post does not create a surprise invoice. Route by task: small models for classification and short answers, mid-tier for retrieval responses, frontier models only where reasoning quality matters. Cache stable answers, cap retries and set internal fair-use budgets per feature so one experiment cannot consume the month. See the live pricing page for current plans.
Build so you never rewrite
Two decisions determine how painful scale will be. First, keep the OpenAI-compatible interface so a provider or deployment change is a base URL and model-name edit. Second, keep retrieval, prompts and evals in version control so model switches can be measured rather than guessed. When you land a larger customer, the same application can move to your VPC, on-prem or an air-gapped environment. That option often decides enterprise deals, and it costs far less when it is an infrastructure setting rather than a rewrite.
Security for a small team
You do not need a compliance program on day one, but you do need hygiene: separate keys per environment, never commit keys to the repository, log requests so debugging and audits are possible, and keep payment and personal data out of prompts. Choose the processing region when your first EU or GCC customer asks. Because the API is compatible, adding these controls later is configuration, not re-architecture. Revisit the setup when you hire your first security engineer or sign your first enterprise contract.
Honest comparison
| Capability | Plugsky | Typical per-token API | Building in-house |
|---|---|---|---|
| API compatibility | OpenAI-compatible chat, embeddings and tools | Usually compatible | Full rewrite |
| Getting started | Free plan, no card, then flat monthly plans | Card usually required | GPU cost from day one |
| Pricing | Flat monthly self-serve, fair-use usage | Per-token, volatile at spikes | GPU plus operations cost |
| Scale path | Cloud to VPC, on-prem or air-gapped | Mostly cloud-only | You operate everything |
| Model choice | 30+ models behind one API | Varies by provider | You host every model |
Frequently asked questions
Can we keep our existing OpenAI SDK code?
Yes. Plugsky is OpenAI-compatible, so a prototype written against the OpenAI SDK keeps working after changing the base URL and model name.
Is there a free plan?
Yes. The free plan includes plugsky-micro and plugsky-lite with no credit card, and there is a 14-day full-access trial when you need frontier models.
How does pricing work?
Self-serve plans are flat monthly with unlimited fair-use usage, which makes burn predictable during growth spikes. See the live pricing page for current plans.
What if a customer requires data residency?
Region selection is available, and you can move to a VPC, on-prem or air-gapped deployment using the same compatible API and code.
Which endpoints are live today?
Chat, streaming, JSON mode, function calling, embeddings, RAG and agents are live. Audio, images, moderation, files, batch, fine-tuning, assistants and responses are coming soon.
Should we build our own models?
Almost never at seed stage. Use an API, invest in retrieval and evaluation, and revisit self-hosting only when volume or constraint makes it economic.
How do we keep costs down?
Route easy tasks to small models, cache stable answers, cap retries and keep prompts tight. Measure cost per active user rather than cost per request.