How to run a Civitai or Hugging Face LoRA through an API (no GPU, no upload)

SpicyAPI — Sat, 10 Oct 2026 12:10:07 +0000

You found a LoRA you like on Civitai or Hugging Face. Running it usually means renting a GPU, installing ComfyUI or a diffusers script, downloading the base checkpoint and keeping all of it alive. If all you want is images or short clips from that LoRA inside your own app, that is a lot of machinery.

This post shows the other route: pass the LoRA's download link in an API request and let a hosted model load it for that one task. The examples use SpicyAPI, which exposes a loras field on 60+ image and video endpoints (FLUX, Z-Image, Qwen-Image, Wan 2.2, LTX-2, MiniMax H3 and more). The platform adds no content filter of its own, so what the LoRA and the base model can produce is what you get back. The same ideas apply to any host that takes a LoRA URL.

1. Pick a LoRA trained for the base you will call

A LoRA only works on the base model it was trained on. A FLUX.1 [dev] LoRA does nothing useful on Z-Image Turbo, and most hosts will not tell you: the task succeeds and the LoRA is silently ignored. So start from the base:

On Civitai, each file version lists its "Base Model" in the details panel.
On Hugging Face, it is usually in the model card and the repo tags.

Also note the trigger word and the recommended strength from the card. You will need both.

The LoRA overview page lists which LoRA families map to which hosted base, so you can match them before you spend anything.

2. Get a direct link to the .safetensors file

The API needs a URL that downloads the weights file itself, not the page about it.

Hugging Face — use resolve, not blob:

https://huggingface.co/OWNER/REPO/resolve/main/FILE.safetensors

A blob link returns an HTML page. Only public repos work; a gated repo answers the download with 401 and the task fails.

Civitai — use the API download link with the version ID (the number behind the Download button), not the model ID:

https://civitai.com/api/download/models/VERSION_ID

In our tests these links loaded without a token, including files Civitai marks as sign-in only. If you ever get a 401, append ?token=YOUR_CIVITAI_KEY.

Your own files — any public HTTPS link to a .safetensors file works, for example a file in your own S3 or R2 bucket.

Nothing is uploaded ahead of time. The weights are fetched for the task, and there is no separate LoRA fee.

3. Send the request

Every model has its own input schema, but the LoRA part looks the same: a loras array of { path, scale } objects. Here is Z-Image Turbo LoRA, which takes up to three LoRAs at a scale from 0 to 4 (1 is neutral):

curl -X POST "https://api.spicyapi.ai/api/v1/jobs/createTask?wait=60" \
  -H "Authorization: Bearer $SPICY_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: lora-demo-001" \
  -d '{
    "model": "alibaba/z-image-turbo-lora/text-to-image",
    "input": {
      "prompt": "TRIGGERWORD, a woman reading by a rain-streaked window at dusk, warm lamp light on her face, city lights behind",
      "aspect_ratio": "3:4",
      "seed": 42,
      "loras": [
        { "path": "https://huggingface.co/OWNER/REPO/resolve/main/FILE.safetensors", "scale": 0.9 }
      ]
    }
  }'

A few details that save time:

?wait=60 holds the connection for up to 60 seconds. If the task finishes in time you get the final record (HTTP 200) straight away; otherwise you get the usual 202 with a taskId and poll.
Idempotency-Key makes a retry of the same request return the same task instead of creating and charging a second one.
Fix the seed while you are tuning. It is the only way to tell whether a change came from the LoRA or from luck.

If you got a 202, poll until state is terminal:

curl "https://api.spicyapi.ai/api/v1/jobs/recordInfo?taskId=TASK_ID" \
  -H "Authorization: Bearer $SPICY_API_KEY"

{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "job_...",
    "state": "succeeded",
    "cost": "0.012",
    "settled": true,
    "output": {
      "assets": [
        { "url": "https://...", "mime": "image/jpeg" }
      ]
    }
  }
}

The asset URL is a signed link valid for about 20 minutes; poll again for a fresh one, or download the file. Results are kept for 14 days.

Want the price first? Send the same body to POST /api/v1/jobs/quote. It returns the estimated charge and the maximum you can be billed, and creates nothing. Image LoRA endpoints are mostly a flat price per image (Z-Image Turbo LoRA is $0.012); video endpoints bill per second of output, so quoting first is worth it there.

4. Check that the LoRA is actually doing something

Because a mismatched or broken LoRA often fails silently, do one A/B run before you scale up:

Run the request once with the LoRA.
Run it again with the same seed and "loras": [].

If the two images look alike, something is off: wrong base, missing trigger word, or a scale too low to matter. Fix that before generating a batch.

5. Tuning strength and stacking

Start at the card's recommended scale, often 0.7 to 1.0. Far above 1 tends to burn in artefacts.
Stack carefully. Two style LoRAs at full strength usually fight. Keep the main one near 1 and bring the second in around 0.5, moving one scale by about 0.2 at a time with the seed fixed.
Trigger word first in the prompt, then the subject, the setting and the light. Concrete lighting ("a warm lamp on the face, neon behind") moves a realism LoRA further than adjectives like "cinematic".
Video models can have more than one slot. Wan 2.2 uses a two-stage sampler, so its LoRAs come as separate HIGH-noise and LOW-noise files; that endpoint takes them in high_noise_loras and low_noise_loras, plus a plain loras field. Put each file in the slot it was trained for.

Limits differ by model (how many LoRAs, what scale range), so read the loras part of the model's inputSchema from the catalog before you hard-code anything.

When this route makes sense

Hosted LoRA calls are a good fit when you want results inside your own app without running GPUs, when you switch LoRAs often, or when you are testing many community LoRAs before committing to one. If you generate around the clock on a single fixed LoRA, your own GPU may work out cheaper; at a few cents per image, most side projects and prototypes never get there.

The full field reference, SDKs (TypeScript, Python, Go, PHP, Java) and a CLI are in the docs.