Skip to main content

Qwen Image 2.1 LoRA image editing revises one to ten source images from a text instruction, with up to three of your own LoRA weights at strengths from 0 to 4. It returns one image at 1k, 1.5k or 2k.

From $0.042/image

Workbench

Input

Image editing
465/5000

Reordering updates prompt references. Removing media also removes its references; review your prompt.

Up to 5,000 characters. There is no negative prompt on this family, so exclusions belong here too. When a LoRA is loaded, keep the prompt describing the scene and let the weights carry the style or the character — restating what the LoRA already knows tends to fight it. at least 1 characters · at most 5000 characters
affects price2/10

Drop files or media links, paste, or browse · Up to 10 files · Max 10 MB · JPG · PNG · WEBP · GIF

  • Image 1
  • Image 2
2 / 10 files
One to ten reference images. The model does not assign roles on its own, so name in the prompt what each source contributes. Every reference adds to the quote, and the LoRA premium sits on top — a ten-source request with three LoRAs at 2k is the most expensive shape this family takes. at least 1 items · at most 10 items
Composes the frame before generation rather than cropping afterwards. Fifteen options, from 3:1 and 21:9 strips to 1:3 and 9:21 columns. All ratios cost the same.
affects price
Sets output size and price: 1k default, 1.5k in between, 2k where skin texture and fabric hold together. Iterate at 1k, promote the keeper to 2k.
Style LoRAs1/3

Next Scene

Up to three weight files, each {path, scale}. path is a direct HTTPS URL to a .safetensors file or a Hugging Face repository — nothing is uploaded to us and nothing is reviewed. scale runs 0 to 4, where 1 is neutral. The file is fetched at generation time, so the first call with new weights is slower: a 1.2 GB LoRA added roughly 25 seconds in our testing. Weights built for a different base can load silently and do almost nothing — verify a new LoRA visibly changes the output before trusting a batch to it. at most 3 items
Output format
JPEGPNGWebP
JPEG by default; PNG for compositing, WebP to ship straight to a page. Does not change the price or the render.
Seed
Steadies a draw so a series stays in the same neighbourhood. Not a reproduction guarantee — the same prompt and seed twice returned two different frames in our testing. no lower than 0 · no higher than 2147483647
Safety checkerOff

SpicyAPI does not run a safety checker on this model. Your prompt and media go to the model as written, and the model itself decides what comes back.

Checking your account before enabling submission and pricing.

Output

Ready for a new run
poolside-blue-hourExample result

Related models and next tasks

Missing the model you need?

Tell us what to add and where you would use it. Requests go to the people who decide what gets onboarded next.

Two things move the quote here, and the weights are not one of them

Qwen Image 2.1 LoRA Editing revises one to ten reference images with up to three of your own weight files loaded. Both endpoints in this family take the same loras array, but they price differently: this one adds to the quote for every reference you attach, while the weights themselves are outside the calculation entirely. So the gap between the cheapest useful request here and the most expensive one is made of sources, not of files — and the failure that is hardest to diagnose still comes from the URL those files live at.

Open the playground
Two things move the quote here, and the weights are not one of them
References
1 to 10 per request, each up to 10 MB; every one of them raises the quote
LoRA entries
Up to 3, each {path, scale}; the count never changes the quote
Quote dimensions
Reference count and resolution tier
Weights source
A direct HTTPS link to a .safetensors file, or a Hugging Face repository
Link validation
None at submit time; a bad path surfaces later as a failed task
Content declaration
No maturity flag, and no review of the weights you point at
Cost shape
The references are the variable, the weights are notThe quote for this endpoint is built from the resolution tier and the number of entries in image_urls, and it grows with every source attached. The loras array is outside that calculation, so three files cost what none do. A request that is expensive here is expensive because of how many references it carries, which is knowable before anything is sent.
Failure shape
A bad weights link fails late and explains nothingNothing about path is checked when the task is accepted. The failure lands at inference and names no cause, which stings more here than on generation because an editing request usually has upload work behind it already. One retry with the array emptied is the cheapest bisection available, and a task that fails this way is not billed.
Symmetry
The same array is declared on both endpointsloras is identical on generation and on editing — up to three entries, each a path and a strength from 0 to 4. A stack settled against a blank frame transfers here as written, which matters because choosing files is cheap on the other endpoint and gets more expensive with every reference you attach on this one.

Integrating the Qwen Image 2.1 LoRA API

Price the request before the upload, not after

Price the request before the upload, not after

Two independent things move the number: how many sources are in image_urls and which resolution tier you asked for. Both are known before anything is sent, and the live estimate above this page already reflects them, so the shape of an expensive request is visible in advance instead of being discovered afterwards in the ledger.

A tenth reference has to earn its place

A tenth reference has to earn its place

The endpoint accepts up to ten sources and each one adds to the quote the same way, which makes reference count the one input worth being strict about. A frame that only repeats what the instruction already says buys nothing and still costs; a frame carrying a garment, a room or a face that words cannot pin down is exactly what the slot is for.

  • Weights and sources fail in different places

    The frames you attach are material you control and upload; the weights are fetched from a third address while the job runs. That asymmetry is the whole diagnostic: when an editing request fails without explanation, re-send it once with the array emptied. A success narrows the cause to the weights URL in a single call, and no amount of rewriting the prompt would have got there faster.

  • Everything except loras matches the base editing endpoint

    One to ten references, a 5,000-character instruction, fifteen aspect ratios, three resolution tiers, the same output containers and seed range, and a schema that rejects undeclared fields. The custom-weights version of this endpoint is the base one plus a single array, which makes moving between them a change of model name rather than a rewrite.

  • Uncensored source material needs no extra field

    There is no maturity flag on the request, no review of the weights you load and no platform filter standing between the request and the model, so uncensored references and weights travel through the same fields as everything else. The instruction is what decides the outcome; nothing in the request shape has to be switched on first.

Who calls the Qwen Image 2.1 LoRA API

  • Count the references before you count the renders

    Teams budgeting a batch

    Count the references before you count the renders

    A hundred edits carrying two sources each and a hundred carrying eight are very different jobs on this endpoint, at the same tier and with the same weights loaded. Fixing a reference count per job type is the single most effective thing you can do to make a batch predictable, because the other dimension is a three-value tier you rarely change.

  • Bisect the request, starting with the array

    Integrators debugging a failed edit

    Bisect the request, starting with the array

    Re-send the same edit with loras emptied and nothing else touched. A success narrows the cause to the weights URL; a second failure sends you back to the references and the instruction. Either answer arrives in one call, against a message that would otherwise have told you nothing at all.

  • Settle the stack on a blank frame first

    Anyone carrying a look across both endpoints

    Settle the stack on a blank frame first

    Choosing weights is cheaper against generation, where the tier is the only thing in the quote. Find the files and the strengths there, then bring the settled array over here, where every attached source is adding to the number and a comparison run costs several times what the same comparison costs next door.

  • Let the weights carry whatever repeats

    Series and catalogue work

    Let the weights carry whatever repeats

    Anything that has to look the same in every frame belongs in a weight file rather than in a reference attached to every single request. Each reference is a per-request cost and the weights are not, so over a long series the same consistency bought two different ways ends up at two very different totals.

How to call the Qwen Image 2.1 LoRA API

  1. Verify the weights link outside this request

    path is fetched at generation time and is not checked when the task is accepted, so a dead link turns into a failed edit after the upload work is already done. Resolve it once, where your service checks its other external dependencies, and re-check it whenever the address changes.

  2. Attach only the references that carry something

    Each entry in image_urls raises the quote and each accepts up to 10 MB. Send the frames holding a property that words cannot pin down — a face, a specific garment, an approved composition — and let the instruction carry the rest of it.

  3. Read the estimate, then send

    Reference count and resolution tier are both folded into the quote shown above the form before submission, and that figure is what settles. Large requests are worth reading rather than assuming, because both dimensions move at once and a tier label on its own does not suggest the total.

  4. Submit the task and poll for a terminal state

    The endpoint is asynchronous: the response carries a handle and the edited image arrives afterwards. Poll until the task reaches a terminal state, then read the image from the result, which is served from platform storage rather than from the address the weights came from.

  5. Empty the array first when something goes wrong

    One retry with loras removed separates a weights problem from a references-or-instruction problem. Do that before rewriting the prompt, because the failure message will not tell you which half of the request you are in and rewriting is the slower of the two guesses.

Qwen Image 2.1 LoRA integration patterns

  • One reference, one loaded weight

    The cheapest useful shape on this endpoint: a single source, a single entry in the array, the default tier. Run it before anything larger so the first result has one source and one file standing behind it.

    Keep the woman's face, hair and expression exactly as they are in the source image, change her surroundings to a sunlit balcony overlooking a harbour in late afternoon
  • A second reference that carries a garment

    Two sources, with the instruction saying outright what each one contributes. The second slot earns its cost here only because the coat is far easier to show than to describe.

    The first image is the person and the second image is the coat; dress the person from the first image in the coat from the second, keep her pose, the background and the lighting unchanged
  • The same edit with the array emptied

    Send a failed edit a second time with loras removed and nothing else changed. A success says the weights URL is the difference; a second failure sends you back to the references and the instruction.

    Keep the person, the pose and the framing from the source image, relight the scene as a dim interior with a single warm lamp behind her

Qwen Image 2.1 LoRA integration questions

Before you wire it in

Two numbers decide what an edit costs — the reference count and the resolution tier — and the weights are in neither of them. Be strict about the first, settle the second last, and choose the files on the generation endpoint where a comparison is cheap. Keep the weights URL under the same scrutiny as any other external dependency: it is not checked when the task is accepted, and the only fast way back from a failure that names no cause is one retry with the array emptied.