Skip to content
lightspace

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.

OpenAI-compatible
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)
Use it toAnswer questionsRead documentsTranscribe audioGenerate imagesEmbed for searchRun agents
Qwen3Llama 3.1Gemma 3gpt-ossDeepSeek-R1PixtralQwen3-VLWhisperFLUX.1SDXLMolmoBGE-M3+14 more →

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.

01

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

02

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

03

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.

OpenAI-compatible
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)
fine-tuning
# 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 workspace

Catalogue

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.

ModelModel IDParamsBest for
Qwen3qwen3-32b32BThe general workhorse: reasoning, long context, 100+ languages
Qwen3 MoEqwen3-30b-a3b30B (3B active)Near-32B quality at a fraction of the latency, for chat volume
Gemma 3gemma3-27b27BMultilingual work across 140+ languages, reads images too
Phi-4phi-4-14b14BMaths and structured reasoning well above its weight. MIT licence
Llama 3.1llama3.1-8b8BThe safe default when a tool or prompt was written for Llama
DeepSeek-R1 Distilldeepseek-r1-distill-8b8BShows 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.

ModelModel IDParamsBest for
gpt-ossgpt-oss-120b117B (5B active)The heavyweight: agentic coding and tool use, on dedicated capacity
gpt-ossgpt-oss-20b21B (4B active)Strong code and tool-calling without the heavyweight price
GLM Z1glm-z1-9b9BAgent loops on a budget: plans, calls tools, stays cheap. MIT

Vision

Images and video in. Documents, screenshots, photographs, frames.

ModelModel IDParamsBest for
Qwen3-VLqwen3-vl-30b30B (3B active)Long documents and hour-long video, OCR across 32 languages
Qwen2.5-VLqwen2.5-vl-7b7BThe default for images: multilingual documents, charts, photos
GLM-4.6V Flashglm-4.6v-flash9BScreenshots and UI: reads an interface, returns structure or code
Pixtralpixtral-12b12BSeveral images in one request at native resolution, 128K context
DeepSeek-OCRdeepseek-ocr3BDense scanned pages: tables, forms, receipts, ~100 languages
InternVL2internvl2-8b8BHigh-resolution pages where small print has to survive
Molmomolmo-7b7BPoints at things: returns coordinates, not just a description
Moondreammoondream-2b2BCheapest per image. Good enough for triage before a bigger model

Speech

Audio in and audio out. Transcription, translation, synthesis.

ModelModel IDParamsBest for
Whisper large-v3whisper-large-v31.6BTranscription and translation in 90+ languages, the known quantity
Parakeetparakeet0.6BFastest transcription on the fleet, for bulk audio and call logs
Qwen3-TTSqwen3-tts1.8BSpeech out, with voice cloning and designed voices
Kokorokokoro0.08BTiny, quick text-to-speech for interfaces and IVR

Embeddings

Vectors for search, retrieval and clustering. The cheapest thing to run.

ModelModel IDParamsBest for
Qwen3-Embeddingqwen3-embedding-8b8BBest retrieval quality in the catalogue, multilingual
Qwen3-Embeddingqwen3-embedding-0.6b0.6BEmbed millions of rows without thinking about the bill
BGE-M3bge-m30.6BDense, sparse and multi-vector retrieval from one model

Images

Image generation, and training on your own style or product catalogue.

ModelModel IDParamsBest for
FLUX.1 schnellflux.1-schnell12BImage generation in a few steps, and cheap to specialise on a style
SDXLsdxl3.5BThe 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
Start free

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
Choose Starter

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
Choose Studio

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
Choose Scale

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 workspace

api.lightspacehq.com