FLUX.1 Kontext is a context-aware image editing model family from Black Forest Labs, available on Novita AI in three tiers: Dev, Pro, and Max. Unlike the FLUX.1 text-to-image models, Kontext takes an existing image plus a text prompt and edits the image while preserving context — changing a subject’s outfit, swapping backgrounds, adjusting typography, or compositing new elements without rebuilding from scratch. This guide covers the differences between the three tiers, their API parameters, pricing, and which one to reach for on Novita AI.
What Is FLUX.1 Kontext?
FLUX.1 Kontext is Black Forest Labs’ image editing model line, distinct from their FLUX.1 and FLUX1.1 text-to-image models. The key capability is context-aware editing: you supply one or more reference images alongside a text instruction, and the model carries through the subject’s identity, style, and spatial relationships into the edited result.
Practical tasks it handles well:
- Changing a character’s clothing, hair color, or accessories while keeping their face
- Swapping or extending backgrounds without affecting the foreground subject
- Editing in-image text and typography (signs, labels, overlays)
- Compositing elements from multiple source images
- Style transfer that preserves structural content
On Novita AI, all three Kontext variants are served through the standard async task API at https://api.novita.ai. You POST to the relevant endpoint, get back a task_id, then poll the Task Result API until the output is ready.
FLUX.1 Kontext vs FLUX.1 Text-to-Image
This distinction matters when choosing the right tool. FLUX.1 [dev] and [schnell] on Novita AI are text-to-image models: they generate images from text prompts alone, with no image input. FLUX.1 Kontext Dev, Pro, and Max are image editing models: they require at least one source image and produce edits grounded in that input.
If you want to generate from scratch, use FLUX.1 [dev] or [schnell]. If you want to edit, retouch, or transform an existing image while preserving its context, use FLUX.1 Kontext.
Which Tier Should You Use?
| Dev | Pro | Max | |
|---|---|---|---|
| Novita AI endpoint | /v3/async/flux-1-kontext-dev | /v3/async/flux-1-kontext-pro | /v3/async/flux-1-kontext-max |
| Price per image | $0.0225 ($0.018 fast) | $0.036 | $0.072 |
| Output size control | Pixel dimensions (256–1536 per side) | Aspect ratio presets | Aspect ratio presets |
| Inference steps | Configurable (1–50, default 28) | Fixed | Fixed |
| Fast mode | Yes (lower cost, slightly reduced quality) | No | No |
| Safety tolerance | No | Yes (1–5, default 2) | Yes (1–5, default 2) |
| Max source images | 4 | 4 | 4 |
| Best for | High-volume pipelines, cost-sensitive workflows, custom resolution needs | Balanced quality and cost, production use | Highest output quality, premium consistency |
Use Dev when: you need cost-efficient throughput, want to tune inference steps or output pixel dimensions, or are running high-volume automated pipelines where fast mode makes sense.
Use Pro when: you want reliable, production-grade edits at a mid-range price point and don’t need to tune inference steps. The aspect ratio interface is simpler to work with for web and social formats.
Use Max when: output quality is the primary concern and cost is secondary. Max targets premium consistency for professional assets, brand imagery, or work where visual fidelity directly affects the end product.
FLUX.1 Kontext Dev on Novita AI
Endpoint: POST https://api.novita.ai/v3/async/flux-1-kontext-dev
Dev gives the most control over generation parameters. You can set exact pixel dimensions rather than aspect ratio presets, tune inference steps, and enable fast mode to reduce cost at the expense of some quality.
Request parameters:
| Parameter | Type | Default | Notes |
|---|---|---|---|
prompt | string | required | Edit instruction |
images | string[] | optional | Base64 or URL; up to 4 images |
fast_mode | boolean | false | Reduces cost to $0.018/image |
size | string | — | width*height, 256–1536 per dimension |
num_inference_steps | integer | 28 | Range 1–50 |
guidance_scale | number | 2.5 | Range 1.0–20.0 |
num_images | integer | 1 | Range 1–4 |
seed | integer | -1 | -1 = random |
output_format | string | jpeg | jpeg, png, webp |
When to tune steps: for simple edits (color change, text replacement), 20 steps is often enough. For complex compositional changes or multi-image blending, 28–35 steps generally improves coherence. Going above 40 steps rarely adds meaningful quality to editing tasks.
FLUX.1 Kontext Pro on Novita AI
Endpoint: POST https://api.novita.ai/v3/async/flux-1-kontext-pro
Pro trades granular step control for a simpler interface and a step up in output quality. You specify aspect ratio rather than pixel dimensions, making it straightforward to target standard formats (1:1 for social, 16:9 for video thumbnails, 9:16 for mobile).
Request parameters:
| Parameter | Type | Default | Notes |
|---|---|---|---|
prompt | string | required | Edit instruction |
images | string[] | optional | Base64 or URL; up to 4 images |
guidance_scale | number | 3.5 | Range 1.0–20.0 |
aspect_ratio | string | — | 1:1, 16:9, 4:3, 3:2, 2:3, 3:4, 9:16, 9:21, 21:9 |
seed | integer | -1 | -1 = random |
safety_tolerance | string | 2 | 1 (strict) to 5 (permissive); text-to-image mode only |
Note: the Novita AI docs indicate safety_tolerance is only applied in text-to-image mode for Pro. When using Kontext for image editing (i.e., passing source images), this parameter has no effect.
FLUX.1 Kontext Max on Novita AI
Endpoint: POST https://api.novita.ai/v3/async/flux-1-kontext-max
Max shares Pro’s interface almost exactly — same aspect ratio presets, same safety tolerance controls — but targets higher consistency and fidelity. If you’re running Pro and the outputs are inconsistent across a batch, or if a specific edit keeps diverging from the source subject, Max is the next step to try.
Request parameters:
| Parameter | Type | Default | Notes |
|---|---|---|---|
prompt | string | required | Edit instruction |
images | string[] | optional | Base64 or URL; up to 4 images |
seed | integer | — | Range -1–2147483647 |
guidance_scale | number | 3.5 | Range 1.0–20.0 |
safety_tolerance | string | 2 | 1 (strict) to 5 (permissive) |
aspect_ratio | string | — | Same presets as Pro |
The main practical difference from Pro is output quality ceiling and pricing. For most API workflows, Pro covers the use case. Max makes sense for final asset production where you need the model’s best output before human review.
How Much Does FLUX.1 Kontext Cost on Novita AI?
Pricing as of 2026-06-26 (source: Novita AI pricing page):
| Variant | Price per image |
|---|---|
| FLUX.1 Kontext Dev | $0.0225 |
| FLUX.1 Kontext Dev (fast mode) | $0.018 |
| FLUX.1 Kontext Pro | $0.036 |
| FLUX.1 Kontext Max | $0.072 |
Novita AI’s prices are lower than BFL’s direct API rates (Pro: $0.04, Max: $0.08 at BFL as of 2026-06-26). For high-volume editing pipelines, the difference adds up quickly: 10,000 Pro edits on Novita costs $360 versus $400 direct.
API Quick Start
Get your API key from the Novita AI console. All three Kontext endpoints use the same async pattern: POST to submit, receive a task_id, then GET from the task result endpoint until the output is ready.
Python example — FLUX.1 Kontext Pro:
import requests
import time
API_KEY = "YOUR_NOVITA_API_KEY"
BASE_URL = "https://api.novita.ai"
def edit_image_kontext_pro(image_url: str, prompt: str, aspect_ratio: str = "1:1") -> str:
response = requests.post(
f"{BASE_URL}/v3/async/flux-1-kontext-pro",
headers={
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
},
json={
"prompt": prompt,
"images": [image_url],
"aspect_ratio": aspect_ratio,
"guidance_scale": 3.5,
},
)
response.raise_for_status()
task_id = response.json()["task_id"]
# Poll for result
while True:
result = requests.get(
f"{BASE_URL}/v3/async/task-result",
headers={"Authorization": f"Bearer {API_KEY}"},
params={"task_id": task_id},
)
result.raise_for_status()
data = result.json()
if data.get("task", {}).get("status") == "TASK_STATUS_SUCCEED":
return data["images"][0]["image_url"]
elif data.get("task", {}).get("status") == "TASK_STATUS_FAILED":
raise RuntimeError(f"Task failed: {data}")
time.sleep(2)Dev variant with fast mode and custom resolution:
response = requests.post(
f"{BASE_URL}/v3/async/flux-1-kontext-dev",
headers={
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
},
json={
"prompt": "Change the jacket to red leather",
"images": [image_url],
"fast_mode": True,
"size": "1024*1024",
"num_inference_steps": 28,
"guidance_scale": 2.5,
"output_format": "webp",
},
)Max variant for highest quality:
response = requests.post(
f"{BASE_URL}/v3/async/flux-1-kontext-max",
headers={
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
},
json={
"prompt": "Replace the background with a sunset over mountains",
"images": [image_url],
"aspect_ratio": "16:9",
"guidance_scale": 3.5,
},
)Practical Editing Patterns
Subject consistency across frames: To keep a character or product identity consistent across a batch, pass the same source image with a varied prompt for each frame. A fixed seed locks the output style within a session.
Multi-image compositing: All three variants accept up to 4 source images. Pass a character reference and a background reference together and instruct the model to composite them. Simpler instructions produce more predictable results.
Typography edits: Kontext handles in-image text better than most editing models. Specify the change explicitly in the prompt: "Change the sign text from 'OPEN' to 'CLOSED'". Pro and Max produce more legible typography edits than Dev, particularly for small or stylized text.
Iterative refinement: Kontext output is just an image — feed it back in as the source for the next edit. Rough edit first with Dev fast mode, final quality pass with Pro or Max.
When to avoid Kontext: For generating images with no source reference, use FLUX.1 Dev text-to-image on Novita AI — Kontext needs source imagery to edit.
Conclusion
FLUX.1 Kontext is a context-aware image editing model family — not a text-to-image system. Its core capability is preserving subject identity, spatial relationships, and style while applying precise text-driven edits to an existing image. That distinction matters when choosing it over FLUX.1 Dev, Schnell, or other T2I models: Kontext is the right tool when you have source imagery and need to change something specific about it.
Across the three tiers on Novita AI, the selection logic is straightforward. Dev is the right choice for high-throughput or cost-sensitive workflows — it exposes inference step control and pixel-level sizing, and fast mode drops the price to $0.018/image. Pro is the default for most production use cases: simpler aspect ratio interface, better output consistency than Dev, and a mid-range price ($0.036/image) that works for ongoing pipelines. Max targets final asset production where quality ceiling matters more than cost — it shares Pro’s interface but delivers higher consistency, making it the right call for brand imagery, print-ready work, or any output that goes directly in front of an audience without further editing.
All three variants accept up to 4 source images and return results through the same async task API, so tier selection is a one-line endpoint change in practice. The right tier depends on where the output lands: automated pipelines lean Dev, production APIs lean Pro, final delivery leans Max.
FAQ
Q: What is the biggest practical difference between Dev, Pro, and Max?
A: Dev gives you direct control over inference steps and output pixel dimensions, plus a fast mode option that reduces cost at the expense of some quality. Pro and Max use aspect ratio presets instead and fix the inference pipeline — Pro is the balanced production option, Max is the higher-quality ceiling. The pricing reflects this: Dev from $0.018, Pro $0.036, Max $0.072 per image on Novita AI (checked 2026-06-26).
Q: Which tier should I start with?
A: Start with Pro. It covers the majority of production image editing use cases with a simple interface and reliable output. Switch to Dev if you need throughput cost control or custom pixel dimensions; move to Max if Pro outputs are inconsistent or if you’re producing final assets that go directly to an audience.
Q: When is it worth upgrading from Pro to Max?
A: When output consistency matters more than cost. Common signals: Pro results drift across a batch when identity preservation is critical (same character or product across many edits), fine typography edits are degrading, or the output goes directly to production without a human QA step. Max doesn’t expose different parameters — it’s the same interface as Pro, just a higher quality ceiling.
Q: Does Dev fast mode noticeably reduce quality?
A: For simple edits — solid color changes, background swaps, object removal — fast mode quality is usually acceptable. For complex compositing, precise typography changes, or edits requiring strong subject consistency, standard Dev or Pro produces more reliable results. Fast mode is best treated as a screening or prototyping tier, not a final output tier.
Q: What is the difference between FLUX.1 Kontext and FLUX.1 text-to-image models?
A: FLUX.1 Kontext (Dev/Pro/Max) is an image editing model: it takes one or more source images plus a text instruction and returns an edited version. FLUX.1 [dev] and [schnell] are text-to-image models: they generate images from a text prompt with no image input required. The two families solve different problems and are not interchangeable — use Kontext when you have source imagery to edit, and T2I models when generating from scratch.
