Key facts
| API compatibility | Drop-in /v1/chat/completions with streaming, JSON mode and function calling (live) |
| Structured extraction | JSON mode for invoices, statements and line items |
| Calculation pattern | Function calling into deterministic tools, never model arithmetic |
| Models | 30+ models behind one API, route extraction and analysis separately |
| Pricing | Flat monthly plans with unlimited fair-use usage on self-serve |
| Migration | Base URL change plus model-name mapping; no algorithm rewrite |
| Controls | Scoped API keys, RBAC, SSO/SCIM and SIEM-exportable audit logs |
| Free tier | plugsky-micro and plugsky-lite on the free plan, no card required |
TL;DR
- Keep the OpenAI SDK; switch the base URL and model IDs to move the workload.
- Use JSON mode for extraction so downstream finance systems get typed fields.
- Route every calculation through function-call tools to keep numbers auditable.
- Per-token experiments should not become permanent billing anchors — model flat plans.
- Validate prompts and schemas in a shadow run before touching production ledgers.
How it works, step by step
- Centralise the model client so base URL, key and model names come from configuration rather than code.
- Define JSON schemas for each extraction task — invoice line items, bank statement rows, trial balances — and test them against real samples.
- Implement calculation tools (FX conversion, variance, aggregation) and expose them through a tools array rather than trusting the model with arithmetic.
- Set the client to the Plugsky base URL with a scoped key, and map model names for extraction and analysis tasks.
- Run a shadow batch over a closed period and diff extracted fields against the source of truth.
- Cut over the batch job or assistant, monitor usage and error rates, and keep the previous provider path behind a config flag.
- Review prompt retention and key scopes with security before enabling any workflow that carries sensitive data.
Try it yourself
Open the LLM cost calculator →
The compatibility surface that matters for finance
Finance workloads lean on three OpenAI-shaped capabilities: chat completions for drafting, JSON mode for extraction that feeds structured systems, and function calling for tools. All three are live on Plugsky. That combination covers invoice coding, statement parsing, reconciliation drafts and commentary generation without introducing a new SDK or request format.
Specialist endpoints — files, batch, fine-tuning, assistants-style runs — are coming soon, so keep bulk document handling and job orchestration in your own pipeline for now. The compatibility guarantee applies to the calls in production today, which is where the value is.
Patterns that keep numbers honest
Two patterns prevent the classic finance failure of plausible wrong numbers. First, extract with JSON mode into typed fields and validate them against your schema before anything downstream reads them. Second, expose calculations as tools and require the model to call them, so every derived value has an execution trace.
- Validation: reject malformed JSON, out-of-range amounts and missing periods rather than repairing them silently.
- Tools: FX rates, totals and variance functions run in code with the same libraries your analysts trust.
- Idempotency: give each extraction a document hash so retries do not duplicate postings.
- Traceability: store the request, response and tool arguments with the resulting journal draft.
Rollout, billing and governance
Run new prompts and schemas in shadow mode over a closed period first. Diff every extracted field against the source system, and only then enable the workflow for a pilot team. Because the client is OpenAI-compatible, rollback is a configuration change rather than a code release.
Billing also changes shape: per-token meters make month-end spikes hard to forecast, while flat monthly plans with fair-use limits keep predictable cost per workflow — though heavy batch users should confirm fair-use terms on the live pricing page. Keep keys scoped per workflow, log tool and model activity for audit, and pin deployments to a region that satisfies your data policy, including VPC or on-prem when required.
Honest comparison
| Aspect | Plugsky | Staying on OpenAI | Self-hosted stack |
|---|---|---|---|
| Code changes | Base URL and model names only | None | Rewrite and retune |
| Structured output | JSON mode live for extraction | Available | You build constraints |
| Tool calculations | Function calling live | Available | You host the runtime |
| Billing shape | Flat monthly with unlimited fair use on self-serve | Per-token | GPU and ops cost |
| Residency | Region choice, VPC, on-prem, air-gapped | Limited options | Wherever you deploy |
Frequently asked questions
Do we need to change our finance prompts?
Mostly no, but validate them. Model behaviour differs between providers, so rerun your prompt suite and schema checks before production and adjust instructions where output drifts.
Is JSON mode reliable for invoices?
It returns valid JSON, but you should still validate fields against your schema — amounts, currencies and dates — and reject invalid records instead of auto-correcting them.
Can the assistant do calculations?
Expose calculations as function-call tools and let the model call them. Arithmetic inside the model is not auditable, and auditability is the point in finance.
How does billing compare?
Self-serve plans are flat monthly with unlimited fair-use usage rather than per-token charges. Check the live pricing page for current plans and fair-use terms before moving large batch workloads.
What about batch and files endpoints?
They are coming soon. Keep large document jobs in your own pipeline and call the live chat and embeddings endpoints for the model work.
Is the migration reversible?
Yes. Keep the base URL and model names in configuration; switching back is the same change in reverse, with no code edits.
How do we start safely?
Use the free plan's plugsky-micro and plugsky-lite models with no card, validate on closed periods, then move to a paid plan or the 14-day full-access trial.