Key facts
| Developer fit | Privacy as configuration: same SDK, different endpoint and boundary |
| Private access | Private endpoints; traffic stays in the deployment you select |
| Key handling | Server-side scoped keys per environment; rotate and revoke |
| Residency | Region-locked planes: EU (Frankfurt), GCC (UAE), APAC (Singapore), US (Virginia) |
| Retention | Configurable prompt retention; confirm your terms in the DPA |
| Models | 30+ models behind one OpenAI-compatible API |
| Pricing | Flat monthly self-serve plans; no per-token billing |
| Free plan | plugsky-micro and plugsky-lite, no card; 14-day full-access trial |
TL;DR
- Keep the OpenAI-compatible surface; change endpoint and boundary, not application code.
- Never ship a key to a client: broker calls server-side with scoped credentials.
- Keep extraction and retrieval behind interfaces so the private path stays composable.
- Set retention and residency deliberately, and verify them in the DPA.
- Test privacy posture with the same evaluation suite you use in cloud.
How it works, step by step
- Read the endpoint, region and model name from environment configuration so the private path needs no code branches.
- Generate scoped keys per environment and store them in your platform's secret manager; never commit them or expose them to browsers.
- Broker model calls through server-side code, attaching credentials at request time.
- Keep extraction and vector retrieval behind interfaces so each stage can move to a private boundary independently.
- Send only the data the task needs: redact identifiers and preferred-format input before prompting.
- Configure retention and residency for the workload, and record the decision in your architecture notes and DPA review.
- Run parity tests against the private endpoint, then monitor usage and errors per key from day one.
Try it yourself
Open the API key security checklist →
Privacy as configuration
The reason private AI is tractable on Plugsky is that the interface does not change. Your code calls an OpenAI-compatible endpoint; whether that endpoint resolves to a shared region, a private endpoint in your VPC or an on-prem appliance is deployment configuration. Models come from the same catalogue of 30+, and streaming, JSON mode, function calling and embeddings behave the same way.
That means privacy work happens in infrastructure and secrets management rather than in application logic — which is exactly where you want it, because those are the parts you can test and review systematically.
Key handling that survives review
Most privacy incidents in AI apps are credential incidents. Keep keys server-side, scope them per environment and service, and rotate on a schedule that a reviewer would accept.
- Environment separation: dev, staging and production keys never overlap.
- Scope: a summarisation worker does not get an action-capable key.
- Rotation: scheduled, plus immediate rotation after any team or vendor change.
- Attribution: log key, user and model metadata so usage is explainable.
Testing and the honest trade-offs
Run the same evaluation suite against the cloud and private endpoints to catch configuration drift — model name, region or retention settings that differ between environments. Keep a smoke test that fails the build if the base URL or key scope is wrong, because privacy misconfigurations are silent until an audit.
Expect private paths to cost more effort: capacity, monitoring and upgrades land on your team. Start on the free plan with plugsky-micro and plugsky-lite to build, use the 14-day full-access trial for realistic load, and compare ongoing costs on the live pricing page. Endpoint coverage is identical in every deployment: chat, streaming, JSON mode, function calling and embeddings are live, while audio, images and files are labelled coming soon.
Honest comparison
| Concern | Plugsky private path | Consumer AI tooling | Rolling your own |
|---|---|---|---|
| Code changes | Endpoint and configuration only | None, but no control | Custom serving and clients |
| Key handling | Server-side scoped keys, rotation | Platform-managed accounts | You build credential management |
| Residency | Region, VPC, on-prem or air-gapped | Vendor-defined | Wherever you deploy |
| Retention | Configurable; confirm in the DPA | Opaque | Fully yours |
| Ops load | Low for cloud, higher for on-prem | Minimal | Highest |
Frequently asked questions
Is a private endpoint a different API?
No. It is the same OpenAI-compatible API surface, so your SDK, prompts and streaming behaviour stay the same; only the endpoint and deployment boundary change.
Can I use private AI without self-hosting?
Yes. Region-locked planes and VPC deployment provide private paths without buying hardware. On-prem and air-gapped are options when policy requires them.
How should I store keys?
In a platform secret manager, injected at runtime, scoped per environment and service, and never committed or shipped to clients.
How do I verify the privacy posture?
Combine configuration review, retention settings and a parity test suite. Confirm the contractual terms in the DPA and keep the decision in your architecture notes.
Does the free plan work for private development?
Yes for development and small services: plugsky-micro and plugsky-lite with no card. Move to a paid plan or the 14-day full-access trial when you need more capacity.
What is live today?
Chat completions with streaming, JSON mode and function calling, plus embeddings. Audio, images, files, batch, moderation, fine-tuning and assistants endpoints are labelled coming soon.
Will private deployment change latency?
It depends on placement: a nearby region or VPC usually improves it, while an on-prem appliance removes WAN variance. Measure from your own network before committing.