LoRA hosting for teams with many clients
Serve every fine-tune from one API.
Upload LoRA adapters for a supported base model, get an OpenAI-compatible endpoint, and see usage and cost for each of your clients — without running GPUs.
No card needed for the sandbox. Responses there are synthetic and never billed.
Works with the tools you already use
- OpenAI Python SDK
- OpenAI Node SDK
- cURL
- Any HTTP client
How it works
Upload an adapter. Get an endpoint.
Upload adapter_config.json and the safetensors weights. We check rank, target modules and tensor shapes, then you give it an alias and call it.
- Validated before it runs — bad files are rejected with the exact reason.
- Aliases, not IDs — switch adapter versions without touching client code.
Per-client reporting
Know what each client costs you.
Assign adapters, deployments and API keys to a client. Every request is attributed to that client, so you see their tokens and cost — and the amount to bill with your markup.
- Markup per client — your cost and the amount to bill, side by side.
- CSV that matches your invoice for the same period.
Developer API
Keep the SDK you already use.
Chat completions follow the OpenAI format. Change the base URL, use your Basevex key, and set model to your deployment alias. Streaming works the same way.
- Endpoint
- POST /v1/chat/completions
- Model name
- your deployment alias
# pip install openai
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.base.devmaagency.com/v1",
api_key=os.environ["BASEVEX_API_KEY"], # e.g. bvx_EXAMPLE-not-a-real-key
)
response = client.chat.completions.create(
model="contract-review", # your deployment alias
messages=[{"role": "user", "content": "Summarize clause 4.2 in one sentence."}],
max_tokens=200,
)
print(response.choices[0].message.content)The key in these samples is a placeholder, not a real credential.
Why one base model
Stop paying for a full model per fine-tune.
Weights loaded once
A LoRA adapter is a small fraction of its base model. Serving adapters on a shared base model avoids loading a separate copy of the model per fine-tune.
Checked before it runs
Your adapter must match the base model’s architecture. We validate rank, target modules and tensor shapes before a deployment can use it.
Pinned revisions
Each base model is pinned to an exact revision, so the weights under your adapter don’t change without notice.
Honest limits
Adapters, caches and active requests all share GPU memory, so we publish limits instead of promising unlimited models.
Pricing
A plan fee, plus the tokens you use.
Start free in the sandbox. Token usage is billed in addition to the monthly plan fee.
Preview prices
Sandbox
$0
Real API, synthetic responses, never billed. For integrating before you pay.
Developer
$19 /month + tokens
Up to 3 adapters, 3 clients and 2 team members.
Production
$79 /month + tokens
Up to 25 adapters, 50 clients and 10 team members.
Tokens on Qwen3-8B: $0.40 per million input tokens, $1.60 per million output tokens.
FAQ
Questions, answered plainly.
What is a LoRA adapter?
A LoRA (low-rank adaptation) adapter is a small set of extra weights produced by fine-tuning. It changes how a base model behaves without retraining or copying the whole model, which is why many adapters can share one base model.
Which base models are supported?
Only the base models listed in your dashboard and on the pricing page, each pinned to an exact revision. Your adapter must have been trained on that same model. We add models when we can serve them reliably.
Can I upload a full fine-tuned model?
No. Basevex hosts LoRA adapters for supported base models. A fully fine-tuned checkpoint has different base weights, so it can’t share a base model with other adapters.
Is the API OpenAI-compatible?
The chat completions endpoint follows the OpenAI request and response format, so the official OpenAI Python and JavaScript SDKs work by changing the base URL. Some parameters, such as tools and multiple choices, aren’t supported yet; the docs list exactly which are.
How is usage billed?
You pay a monthly plan fee plus input and output tokens at the rates for your base model. Token counts come from the inference runtime, never from the client. Tokens are billed in addition to the plan fee.
What is the sandbox?
Every new organization starts in the sandbox. You can upload adapters, create deployments and call the real API, but responses are synthetic, clearly labeled, and never billed. Subscribe to a plan to switch to real inference.
What happens when I hit my spend cap?
If you set a monthly cap, requests that could push you over it are rejected with a spend_cap_reached error until the next month or until you raise the cap. You get emails at 80% and 100%.
Do you store my prompts?
No. We record request metadata — time, deployment, token counts, latency and status — for usage and billing. Prompts and model outputs are not stored or logged.
Try it with your own adapter.
The sandbox is free. Integrate against the real API, then subscribe when you’re ready for real inference.