# wan-2.2-spicy/image-to-video-lora

> Generate AI videos with personalized styles using LoRA. Upload images and apply a trained style model to WAN 2.2 — create unique, stylized videos with consistent visual identity.

- **Provider:** AirCube
- **Category:** lora-support
- **Price:** $0.2000 per run

## Key Features

- LoRA-powered personalization — apply custom-trained LoRA models to generate videos with unique, consistent visual styles.
- Triple LoRA architecture — standard LoRA, High Noise LoRA, and Low Noise LoRA slots for maximum control over style transfer.
- Up to 3 LoRAs per group — stack multiple LoRAs with individual strength weights for complex style blending (up to 9 total).
- Reproducible results — use the seed parameter to generate deterministic output for consistent iterations.
- Animate still images into smooth, high-quality video with natural motion at 30fps.
- Multiple resolution options — 480p for quick previews or 720p for production, with optional FHD upscaling.
- Flexible duration — generate 5-second or 8-second video clips.

## Parameters

| Parameter | Required | Description |
| --- | --- | --- |
| `prompt` | Yes | Text description of the motion, scene dynamics and desired visual style. |
| `image` | Yes | Source image URL to animate. |
| `duration` | No | Video length: 5 or 8 seconds (default: 5). |
| `aspect_ratio` | No | Output ratio: 16:9, 9:16, 4:3, 3:4, 1:1, 3:2, 2:3 (default: 16:9). |
| `resolution` | No | Output resolution: 480p, 720p (default: 480p). |
| `loras` | No | JSON array of standard LoRA filenames (safetensors), e.g. ["style.safetensors"]. Max 3. |
| `lora_strengths` | No | JSON array of strength values for each standard LoRA, e.g. [1.0]. Must match loras length. |
| `loras_high` | No | JSON array of High Noise LoRA filenames (safetensors), e.g. ["LORA_I2V_xxx_H.safetensors"]. Max 3. |
| `lora_strengths_high` | No | JSON array of strength values for each High Noise LoRA, e.g. [1.0]. Must match loras_high length. |
| `loras_low` | No | JSON array of Low Noise LoRA filenames (safetensors), e.g. ["LORA_I2V_xxx_L.safetensors"]. Max 3. |
| `lora_strengths_low` | No | JSON array of strength values for each Low Noise LoRA, e.g. [1.0]. Must match loras_low length. |
| `seed` | No | Random seed for reproducible results. -1 for random (default: -1). |

## How to Use

1. Upload a high-quality source image that you want to animate.
2. Write a prompt describing the desired motion and visual style.
3. Add your LoRA filenames under Standard, High Noise, and/or Low Noise groups, with strength weights (default 1.0).
4. Optionally set a seed for reproducible results.
5. Set duration and resolution, then generate.

## Code Examples

### Python

```python
import os
import requests

response = requests.post(
    "https://aircube.ai/api/v3/wan-2.2-spicy/image-to-video-lora",
    headers={
        "Authorization": "Bearer " + os.environ["AIRCUBE_API_KEY"],
        "Content-Type": "application/json",
    },
    json={
    "prompt": "Camera slowly orbits around the subject, hair flowing gently in the breeze",
    "image": "https://example.com/portrait.jpg",
    "duration": 5,
    "loras": [
        "style.safetensors"
    ],
    "lora_strengths": [
        1
    ],
    "loras_high": [
        "style_lora_H.safetensors"
    ],
    "lora_strengths_high": [
        1
    ],
    "loras_low": [
        "style_lora_L.safetensors"
    ],
    "lora_strengths_low": [
        1
    ],
    "seed": -1
},
    timeout=300,
)
data = response.json()

if data["success"]:
    print("ID:", data["data"]["id"], "Status:", data["data"]["status"])
else:
    print("Error:", data["error"]["message"])
```

### Node.js

```javascript
const response = await fetch("https://aircube.ai/api/v3/wan-2.2-spicy/image-to-video-lora", {
  method: "POST",
  headers: {
    "Authorization": "Bearer " + process.env.AIRCUBE_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
  "prompt": "Camera slowly orbits around the subject, hair flowing gently in the breeze",
  "image": "https://example.com/portrait.jpg",
  "duration": 5,
  "loras": [
    "style.safetensors"
  ],
  "lora_strengths": [
    1
  ],
  "loras_high": [
    "style_lora_H.safetensors"
  ],
  "lora_strengths_high": [
    1
  ],
  "loras_low": [
    "style_lora_L.safetensors"
  ],
  "lora_strengths_low": [
    1
  ],
  "seed": -1
}),
});

const data = await response.json();

if (data.success) {
  console.log("ID:", data.data.id, "Status:", data.data.status);
} else {
  console.error("Error:", data.error.message);
}
```

### cURL

```curl
curl -X POST "https://aircube.ai/api/v3/wan-2.2-spicy/image-to-video-lora" \
  -H "Authorization: Bearer $AIRCUBE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "prompt": "Camera slowly orbits around the subject, hair flowing gently in the breeze",
  "image": "https://example.com/portrait.jpg",
  "duration": 5,
  "loras": [
    "style.safetensors"
  ],
  "lora_strengths": [
    1
  ],
  "loras_high": [
    "style_lora_H.safetensors"
  ],
  "lora_strengths_high": [
    1
  ],
  "loras_low": [
    "style_lora_L.safetensors"
  ],
  "lora_strengths_low": [
    1
  ],
  "seed": -1
}'
```

### Python (Async)

```python
import os
import time
import requests

# 1. Submit
response = requests.post(
    "https://aircube.ai/api/v3/wan-2.2-spicy/image-to-video-lora",
    headers={
        "Authorization": "Bearer " + os.environ["AIRCUBE_API_KEY"],
        "Content-Type": "application/json",
    },
    json={
    "prompt": "Camera slowly orbits around the subject, hair flowing gently in the breeze",
    "image": "https://example.com/portrait.jpg",
    "duration": 5,
    "loras": [
        "style.safetensors"
    ],
    "lora_strengths": [
        1
    ],
    "loras_high": [
        "style_lora_H.safetensors"
    ],
    "lora_strengths_high": [
        1
    ],
    "loras_low": [
        "style_lora_L.safetensors"
    ],
    "lora_strengths_low": [
        1
    ],
    "seed": -1
},
    timeout=300,
)
data = response.json()

if not data["success"]:
    print("Error:", data["error"]["message"])
    exit(1)

generation_id = data["data"]["id"]
print(f"Submitted: {generation_id}")

# 2. Poll until completed
while True:
    time.sleep(5)
    r = requests.get(
        f"https://aircube.ai/api/v3/status/{generation_id}",
        headers={"Authorization": "Bearer " + os.environ["AIRCUBE_API_KEY"]},
    )
    result = r.json()["data"]

    if result["status"] == "completed":
        print(result["output_url"])
        break
    elif result["status"] == "failed":
        print("Generation failed")
        break
```

### Node.js (Async)

```javascript
// 1. Submit
const response = await fetch("https://aircube.ai/api/v3/wan-2.2-spicy/image-to-video-lora", {
  method: "POST",
  headers: {
    "Authorization": "Bearer " + process.env.AIRCUBE_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
  "prompt": "Camera slowly orbits around the subject, hair flowing gently in the breeze",
  "image": "https://example.com/portrait.jpg",
  "duration": 5,
  "loras": [
    "style.safetensors"
  ],
  "lora_strengths": [
    1
  ],
  "loras_high": [
    "style_lora_H.safetensors"
  ],
  "lora_strengths_high": [
    1
  ],
  "loras_low": [
    "style_lora_L.safetensors"
  ],
  "lora_strengths_low": [
    1
  ],
  "seed": -1
}),
});
const data = await response.json();

if (!data.success) {
  console.error("Error:", data.error.message);
  process.exit(1);
}

const generationId = data.data.id;
console.log("Submitted:", generationId);

// 2. Poll until completed
while (true) {
  await new Promise((r) => setTimeout(r, 5000));
  const res = await fetch(
    `https://aircube.ai/api/v3/status/${generationId}`,
    { headers: { "Authorization": "Bearer " + process.env.AIRCUBE_API_KEY } },
  );
  const result = (await res.json()).data;

  if (result.status === "completed") {
    console.log(result.output_url);
    break;
  } else if (result.status === "failed") {
    console.error("Generation failed");
    break;
  }
}
```

### cURL (Async)

```curl
# 1. Submit
RESPONSE=$(curl -s -X POST "https://aircube.ai/api/v3/wan-2.2-spicy/image-to-video-lora" \
  -H "Authorization: Bearer $AIRCUBE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "prompt": "Camera slowly orbits around the subject, hair flowing gently in the breeze",
  "image": "https://example.com/portrait.jpg",
  "duration": 5,
  "loras": [
    "style.safetensors"
  ],
  "lora_strengths": [
    1
  ],
  "loras_high": [
    "style_lora_H.safetensors"
  ],
  "lora_strengths_high": [
    1
  ],
  "loras_low": [
    "style_lora_L.safetensors"
  ],
  "lora_strengths_low": [
    1
  ],
  "seed": -1
}')

ID=$(echo "$RESPONSE" | jq -r '.data.id')
echo "Submitted: $ID"

# 2. Poll until completed
while true; do
  sleep 5
  STATUS_RES=$(curl -s "https://aircube.ai/api/v3/status/$ID" \
    -H "Authorization: Bearer $AIRCUBE_API_KEY")
  STATUS=$(echo "$STATUS_RES" | jq -r '.data.status')

  if [ "$STATUS" = "completed" ]; then
    echo "$STATUS_RES" | jq -r '.data.output_url'
    break
  elif [ "$STATUS" = "failed" ]; then
    echo "Generation failed"; break
  fi
done
```

## Pricing

| Resolution | Duration | Cost |
| --- | --- | --- |
| 480p | 5s | $0.20 |
| 480p | 8s | $0.40 |
| 720p | 5s | $0.32 |
| 720p | 8s | $0.64 |

### Billing Rules

- 480p / 5s: $0.20.
- 720p / 5s: $0.32.
- Longer durations scale proportionally.
- Failed generations are not charged.

## Best Use Cases

- Branded content — apply trained brand LoRAs for consistent visual identity across generated videos.
- Character animation — use character-specific LoRAs for stylized, on-brand character motion.
- Art style transfer — blend artistic style LoRAs to animate images in specific visual aesthetics.
- Product showcases — combine product-trained LoRAs with motion prompts for styled marketing videos.

## Pro Tips

- Standard LoRA applies across the full generation; High Noise LoRA affects the initial diffusion pass (coarse structure/style); Low Noise LoRA affects the refinement pass (fine details).
- Start with strength 1.0 and adjust — lower values (0.3-0.7) give subtle effects, higher values (1.2-2.0) for stronger style influence.
- You can stack different LoRAs: e.g. one for style + one for character in the same group.
- If the output looks over-stylized, reduce LoRA strength or use fewer groups.
- Use the seed parameter to lock in a good result, then experiment with LoRA combinations while keeping the same seed.
- Use short 5s durations to iterate quickly on LoRA combinations, then extend to 8s for final renders.

## Notes

- LoRA files must be in safetensors format and accessible by the backend.
- Each LoRA group (Standard / High / Low) supports up to 3 LoRAs, for a maximum of 9 total.
- If lora_strengths is omitted, each LoRA defaults to strength 1.0.
- Seed -1 (default) generates a random seed each time.
- Input images should be under 10 MB (JPEG, PNG, WebP).

## FAQ

**Q: What is the Wan 2.2 Spicy LoRA API?**

Wan 2.2 Spicy with LoRA support lets you animate images into videos while applying custom-trained LoRA style models for personalized visual output.

**Q: What are the three LoRA groups?**

Standard LoRA applies across the full generation pipeline. High Noise LoRA influences the early denoising steps (overall composition and style). Low Noise LoRA affects the later steps (fine details and texture). You can use any combination of the three.

**Q: How many LoRAs can I use at once?**

Up to 3 LoRAs per group (Standard, High Noise, Low Noise), for a maximum of 9 LoRAs total per generation.

**Q: What does the seed parameter do?**

The seed controls the random number generator. Using the same seed with the same inputs produces identical results, useful for iterating on LoRA combinations. Set to -1 for a random seed.

**Q: Can I use this without any LoRA?**

Yes — all LoRA and seed fields are optional. Without them, it behaves like the standard Wan 2.2 Spicy image-to-video model.