26 open models · one endpoint
Run open models
with an API.
Run them, train them on your own data, take the weights and go.
No card. 20 minutes on us.
from openai import OpenAI
client = OpenAI(
base_url="https://api.lightspacehq.com/v1",
api_key=os.environ["LIGHTSPACE_API_KEY"],
)
r = client.chat.completions.create(
model="qwen2.5-vl-7b",
messages=[{"role": "user", "content": [
{"type": "text", "text": "Invoice number, date and total as JSON."},
{"type": "image_url",
"image_url": {"url": "https://example.com/invoice.jpg"}},
]}],
)
print(r.choices[0].message.content)Three ways in
Run it, train it, or take it apart.
Open models are not a cheaper version of a closed API — they are a different deal. You can look inside them, change them, move them, and keep what you build. We charge you for the compute and stay out of the way. One key covers all three.
Run it
One request, one model name. Models are kept warm and ready, you pay only for what you send, and switching model is a one-word change in the request body.
Every model in the catalogue · metered by the second · no minimum
Train it
Fine-tune on your own data, distil a big model into a small one, or keep pretraining where the stock model runs out. Your version gets its own model ID on the same endpoint — and the weights come back to you as a file.
Your data trains your model only · weights are yours to download
Do whatever you want with it
Reserved capacity that is yours. Batch jobs, evaluation runs, a custom runtime, your own weights, an architecture nobody else serves. If it is open, we will run it — and we will help you get it running.
Reserved capacity · your weights or ours · fixed monthly cost
The API
The API you already know.
It is OpenAI-compatible. Point your existing client at our base URL, change the model name, and everything else — streaming, tool calls, JSON mode — works the way it already does.
from openai import OpenAI
client = OpenAI(
base_url="https://api.lightspacehq.com/v1",
api_key=os.environ["LIGHTSPACE_API_KEY"],
)
r = client.chat.completions.create(
model="qwen2.5-vl-7b",
messages=[{"role": "user", "content": [
{"type": "text", "text": "Invoice number, date and total as JSON."},
{"type": "image_url",
"image_url": {"url": "https://example.com/invoice.jpg"}},
]}],
)
print(r.choices[0].message.content)# 1. your examples: one {"messages": [...]} per line
f = client.files.create(
file=open("invoices.jsonl", "rb"),
purpose="fine-tune",
)
# 2. train
job = client.fine_tuning.jobs.create(
model="qwen2.5-vl-7b",
training_file=f.id,
suffix="invoices",
)
# 3. watch it happen
for e in client.fine_tuning.jobs.list_events(job.id).data:
print(e.level, e.message)
# 4. is it any good? we grade it, you decide
report = requests.get(
f"https://api.lightspacehq.com/v1/fine_tuning/jobs/{job.id}/report",
headers={"Authorization": f"Bearer {key}"},
).json()
print(report["verdict"], "-", report["headline"])
# red - Not ready. Fix what is flagged below and train again.- /v1/chat/completions
- Language, code and vision. Streaming, tools, JSON mode.
- /v1/embeddings
- Vectors for search and retrieval.
- /v1/files
- Upload training data. Validated line by line on the way in.
- /v1/fine_tuning/jobs
- Train a private model. Events, checkpoints and a verdict.
- /v1/fine_tuning/jobs/{id}/weights
- Download what you trained. It is yours.
- /v1/models
- The live catalogue, your fine-tunes included.
What you can do with it
Run it, teach it, keep it.
The same key does all three. Nothing here is a different product with a different bill.
Inference
Text, code, vision, speech and embeddings through one OpenAI-compatible endpoint. Send an image and ask about it; stream tokens; call tools. Your existing client works unchanged.
- Every model in the catalogue, one key
- Streaming, tool calls and JSON mode
- Usage broken down per key and per model
Fine-tuning
Upload examples, start a job, watch the loss fall. We grade the result and tell you plainly whether it is safe to use — not just a chart and good luck.
- Live events, checkpoints and per-step loss
- A verdict: ready, use with care, or not ready
- Download the adapter and run it anywhere
Self-learning
Keep what the model answered in production, correct what it got wrong, and train on the corrections. Only reviewed answers are used — a model trained on its own unreviewed output just learns to agree with itself.
- Off by default; your prompts, your call
- Mark an answer good, or write the right one
- One click turns corrections into a training file
You can see all of it
The workspace shows what is happening, not a spinner: how much of today you have used, every training run with its loss curve, what was checked and why it passed or failed, and exactly what the weights are before you download them — size, format, and that they load in anything that reads a LoRA adapter.
Open the workspaceCatalogue
Choose the model, not the vendor.
Every model here is open-weight, so nothing can be deprecated out from under you, and every one answers on the same endpoint with the same request shape.
Language
Text in, text out. Chat, extraction, summarisation, classification.
| Model | Model ID | Params | Best for |
|---|---|---|---|
| Qwen3 | qwen3-32b | 32B | The general workhorse: reasoning, long context, 100+ languages |
| Qwen3 MoE | qwen3-30b-a3b | 30B (3B active) | Near-32B quality at a fraction of the latency, for chat volume |
| Gemma 3 | gemma3-27b | 27B | Multilingual work across 140+ languages, reads images too |
| Phi-4 | phi-4-14b | 14B | Maths and structured reasoning well above its weight. MIT licence |
| Llama 3.1 | llama3.1-8b | 8B | The safe default when a tool or prompt was written for Llama |
| DeepSeek-R1 Distill | deepseek-r1-distill-8b | 8B | Shows its working: step-by-step reasoning at small-model cost |
Code & agents
Models that call tools and write code, for agent loops rather than conversation.
| Model | Model ID | Params | Best for |
|---|---|---|---|
| gpt-oss | gpt-oss-120b | 117B (5B active) | The heavyweight: agentic coding and tool use, on dedicated capacity |
| gpt-oss | gpt-oss-20b | 21B (4B active) | Strong code and tool-calling without the heavyweight price |
| GLM Z1 | glm-z1-9b | 9B | Agent loops on a budget: plans, calls tools, stays cheap. MIT |
Vision
Images and video in. Documents, screenshots, photographs, frames.
| Model | Model ID | Params | Best for |
|---|---|---|---|
| Qwen3-VL | qwen3-vl-30b | 30B (3B active) | Long documents and hour-long video, OCR across 32 languages |
| Qwen2.5-VL | qwen2.5-vl-7b | 7B | The default for images: multilingual documents, charts, photos |
| GLM-4.6V Flash | glm-4.6v-flash | 9B | Screenshots and UI: reads an interface, returns structure or code |
| Pixtral | pixtral-12b | 12B | Several images in one request at native resolution, 128K context |
| DeepSeek-OCR | deepseek-ocr | 3B | Dense scanned pages: tables, forms, receipts, ~100 languages |
| InternVL2 | internvl2-8b | 8B | High-resolution pages where small print has to survive |
| Molmo | molmo-7b | 7B | Points at things: returns coordinates, not just a description |
| Moondream | moondream-2b | 2B | Cheapest per image. Good enough for triage before a bigger model |
Speech
Audio in and audio out. Transcription, translation, synthesis.
| Model | Model ID | Params | Best for |
|---|---|---|---|
| Whisper large-v3 | whisper-large-v3 | 1.6B | Transcription and translation in 90+ languages, the known quantity |
| Parakeet | parakeet | 0.6B | Fastest transcription on the fleet, for bulk audio and call logs |
| Qwen3-TTS | qwen3-tts | 1.8B | Speech out, with voice cloning and designed voices |
| Kokoro | kokoro | 0.08B | Tiny, quick text-to-speech for interfaces and IVR |
Embeddings
Vectors for search, retrieval and clustering. The cheapest thing to run.
| Model | Model ID | Params | Best for |
|---|---|---|---|
| Qwen3-Embedding | qwen3-embedding-8b | 8B | Best retrieval quality in the catalogue, multilingual |
| Qwen3-Embedding | qwen3-embedding-0.6b | 0.6B | Embed millions of rows without thinking about the bill |
| BGE-M3 | bge-m3 | 0.6B | Dense, sparse and multi-vector retrieval from one model |
Images
Image generation, and training on your own style or product catalogue.
| Model | Model ID | Params | Best for |
|---|---|---|---|
| FLUX.1 schnell | flux.1-schnell | 12B | Image generation in a few steps, and cheap to specialise on a style |
| SDXL | sdxl | 3.5B | The workhorse generator, with the widest LoRA ecosystem |
Bring your own model
Your weights, your endpoint.
If you have trained or fine-tuned something of your own, we make it run and put it behind the same API, the same key and the same response shape as everything in the catalogue. Your model gets an ID; your code does not change.
- We do the porting. You send the weights. We get them running on our capacity and show you what the model scores before and after, so nothing is traded away without you seeing it.
- Capacity that is only yours. No shared queue, no neighbours, predictable latency, and a monthly cost that does not move with how much you use it.
- Your data stays yours. Requests are processed and dropped. Nothing is retained, and nothing you send is ever used to train a model — ours or anyone else's.
What you get
- A private model ID
- Callable by anyone holding your key, invisible to everyone else.
- Warm start
- Your models stay loaded, so the first request of the day is as quick as the hundredth.
- A fixed monthly bill
- Priced per month, not per request. Usage can spike; the invoice does not.
Pricing
One price, every model.
A flat monthly price on shared capacity. Language, code, vision, speech, embeddings and images are all included, with no per-request charge and no overage — the number you pick is the number you pay.
Free
$0forever
Enough to wire up the API, try three or four models and decide whether this is for you.
- Every model in the catalogue
- 1 API key
- Community support
Starter
$15per month
For one product in production with steady, modest traffic.
- Every model in the catalogue
- 5 API keys, scoped per project
- Usage broken down per key and per model
- Email support
Studio
$49per month
For a team shipping several things at once, and the plan where fine-tuning starts to make sense.
- Everything in Starter
- Unlimited keys
- Private model IDs on the shared endpoint
- Priority over free traffic
Scale
$149per month
All-day capacity with no per-token meter running anywhere in the background.
- Everything in Studio
- Priority queue ahead of lower plans
- Shared Slack channel
- Direct line to the people who run it
Against metered APIs
The large providers meter every token: roughly$0.40 in / $1.60 out per million on a small frontier model, and $0.80 / $4.00 on a fast one. Here the meter does not exist. The number on the card is the invoice.
Against renting a GPU
A dedicated H100 rents for $6.50–$10.00 an hour, an A100 for about $4.00. Scale is$149 a month for up to 24 hours of model time a day — near $0.21 a model-hour.
Why it can be this low
Every plan runs on shared capacity. That is the trade: you share the machines, and the price reflects it. Want a machine to yourself, with the throughput guarantees that come with one?Ask for dedicated— it is priced against those GPU-hour rates, not against these.
Open weights, always
Public, permissively licensed models. Nothing gets retired or re-priced underneath you.
Your training is portable
Train here, download the result, run it anywhere. Not a fine-tune you can only call through us.
Your data is not the product
Requests are processed and dropped. Nothing you send trains anything.
Common questions.
What makes this cheaper than a closed model API?+
Two things. Open models carry no licence fee, so you are not paying for the right to call someone's private model. And every plan runs on shared capacity we own rather than GPU rented by the second, so there is no per-token meter at all: a flat monthly price from $15, against roughly $0.40 in and $1.60 out per million tokens on a small frontier model and $0.80 and $4.00 on a fast one.
How does the flat price compare with renting a GPU?+
A dedicated H100 rents for $6.50 to $10.00 an hour and an A100 for about $4.00. The Scale plan is $149 a month for up to 24 hours of model time a day, which works out near $0.21 a model-hour. That is what sharing capacity buys you.
Can I get a machine to myself?+
Yes, and it is the one thing here that is not cheap. Dedicated capacity is quoted against GPU-hour rates rather than against the shared plans, because you are no longer sharing. Almost nobody needs it: ask only if you have throughput or isolation requirements the shared endpoint cannot meet.
Is there a free tier, and do I need a card to start?+
There is a free tier with a daily allowance across every model in the catalogue, and no card is needed to open a workspace. You add a card only when you outgrow the free allowance.
Is the API compatible with the OpenAI SDK?+
Yes. Point the OpenAI client at https://api.lightspacehq.com/v1 with a Lightspace key and change the model name. Chat, embeddings, audio and image endpoints follow the same shapes, including streaming, tool calls and the fine-tuning endpoints.
Can I train a model, and do I get the weights?+
Yes to both. Send a dataset and we fine-tune, distil or continue pretraining any catalogue model, then serve the result as your own model ID. The trained weights are returned to you in a standard format to download and run anywhere. You can also bring your own open weights and have them served on dedicated capacity.
What does fine-tuning cost?+
Fine-tuning is included in the plan, not billed as a separate training rate. Each plan carries a daily allowance of platform time that inference, training and fine-tuning all draw from, so a fine-tuning run does not arrive as a surprise line on an invoice.
Can I sign up from anywhere?+
Yes. The API is open to developers in any country, prices are shown in your own currency, and card payments run through a merchant of record, so VAT and sales tax are settled wherever you are. No enterprise minimum, and no sales call before your first request.
Which open source models can I run?+
The catalogue covers language and code, vision, speech, embeddings and image generation — models in the Qwen, Llama, Gemma, DeepSeek, gpt-oss, Pixtral, Whisper, FLUX and BGE families among others. Every one of them is open-weight, and the catalogue page lists what is serving right now.
Start on the free tier.
Every model in the catalogue, no card.
Open your workspaceapi.lightspacehq.com