HiAPI
Эта статья пока недоступна на вашем языке — показываем оригинал.
Блог

Tutorial

FIBO 2.0 Practical Guide: 5 High-Value Image Generation Use Cases

How to pick between text-to-image and image-to-image, structure prompts, and control output for real product work

Nov 16, 2026 14 min read
Cover art: nested flat chevron arrows advancing on a deep indigo ground, apricot leading edges and supporting color blocks, in a signal-flow geometric style.
На этой странице

Why FIBO 2.0 Fits Developer Workflows

FIBO 2.0 is an image model family that exposes exactly two routes: text-to-image and image-to-image. That is the whole shape of the integration surface. You pick the route that matches your task, pass a small set of documented parameters, and get a single image back. There is no resolution tier to negotiate, no quality slider to tune, and no hidden capability matrix to reverse-engineer from flaky behavior.

The billing model is equally flat: every call is billed per image, at the same rate on both routes. That symmetry matters more than it first appears. It means your cost model does not need to branch by route, and an edit costs the same as a fresh generation, so you can decide between "regenerate from scratch" and "edit the existing asset" purely on quality grounds rather than on price.

A useful mental model is a single inbox with two doors. On the left door you submit a prompt; on the right door you submit one to four images plus an instruction. Both doors lead to one output image and one billed call.

This guide walks through five use cases that cover most production image work: campaign visuals, photographic product scenes, reference-guided composition, masked retouching, and multi-image recombination. Along the way we will pin down the parameters that actually change behavior — aspect_ratio, seed, style, image_url, image_urls, and mask_url — and the conflicts between them.

A single input forks into two same-priced routes and converges on one output frame, matching FIBO 2.0's unified dual-path workflow.

Choosing Between Text-to-Image and Image-to-Image

The decision rule is about where the visual information comes from.

Use text-to-image when the image does not exist yet and the prompt carries the intent. You supply prompt and nothing else is required. The route also accepts an optional image_url as a visual reference for the scene, which makes it useful for "generate something new, but in the spirit of this" work.

Use image-to-image when pixels already exist and you want them changed, extended, or recombined. This route requires image_urls (1–4 public URLs) and instruction describing what to change. The first image is the one being edited; the rest are references.

A few practical tie-breakers:

  • No starting asset? Text-to-image. There is no way to edit your way into existence.
  • Need an exact mask region preserved? Image-to-image with mask_url, and only with a single input image.
  • Want a specific photographic look applied? Text-to-image with style. The style enum cannot be combined with a reference image_url, and it does not exist on the image-to-image route at all.
  • Have a layout you must respect? Image-to-image with a reference set, or text-to-image with image_url if you only need the general scene.
  • Need a different framing? Both routes expose aspect_ratio, but image-to-image defaults to following the first input image, so an explicit ratio is an override rather than the norm.

If you find yourself describing an existing image in a prompt so the model can "recreate" it, you have picked the wrong route. Pass the image instead.

Both routes are visible on their model pages: FIBO 2.0 text-to-image and FIBO 2.0 image-to-image.

Use Case 1: On-Demand Marketing and Campaign Visuals

Campaign work is the cleanest fit for text-to-image: you have a brief, not an asset, and you need the same visual idea at several shapes.

The aspect_ratio enum is long and deliberately practical — 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 16:10, 10:16, 2:1, 1:2, 21:9, 9:21, 3:1, 1:3, 4:1, 1:4, 5:1, 1:5. That covers square social, vertical story, landscape banner, and the extremely wide or tall placements that usually force a designer to extend a canvas.

Plan ratio-first

Treat aspect_ratio as part of your asset spec, not a post-processing concern. The output is about one megapixel regardless of which ratio you choose, so a tall 9:16 frame and a wide 21:9 frame carry roughly the same pixel budget, just distributed differently. Choosing the ratio up front means your layout gets a composition designed for that frame instead of a center crop of a square.

A workable loop:

  1. Fix the prompt that expresses the campaign motif.
  2. Fix seed so the motif stays recognizable across ratios.
  3. Issue one call per ratio in your placement list.
  4. Store the seed alongside the creative record.

Step 2 is the part teams skip. Because the same seed and prompt reproduce the same image, a fixed seed gives you a stable anchor while you vary aspect_ratio. Expect the composition to adapt to the new frame — it is not a crop — but the underlying idea stays close enough to read as one campaign. If a specific ratio drifts too far, bump the seed for that placement only and record the exception.

Cost planning is straightforward: one output image, one billed call, at the same per-image rate as every other FIBO 2.0 request. A five-placement campaign is five calls. Budget retries explicitly rather than assuming first-pass acceptance.

Different aspect-ratio frames all feed into one consistent, repeatable visual motif — ratio-first asset planning for a campaign family.

Use Case 2: Photographic Product and Lifestyle Scenes

The style parameter is the most underused lever in the family. It accepts four values: Kodak Film, Hard Flash, Hazy Dreamy, and Rough Realism. Each shifts the photographic character of the output, which is exactly what lifestyle and product imagery usually needs — the difference between a clinical render and a photo that looks like it was taken by a person in a room.

Rough guidance on when each earns its place:

  • Kodak Film — warm, nostalgic, editorial. Good for heritage product lines, seasonal campaigns, and lifestyle scenes where you want the image to feel captured rather than constructed.
  • Hard Flash — direct, high-contrast, slightly raw. Works for streetwear, nightlife, and product shots that want energy over polish.
  • Hazy Dreamy — soft, diffused, atmospheric. Suits beauty, wellness, and anything where the mood is the product.
  • Rough Realism — grounded and unglamorous. Useful when you need the image to read as documentary rather than commercial.

The one rule that catches people

style cannot be combined with a reference image on the text-to-image route. If you pass image_url, leave style out. The two are mutually exclusive, and it makes sense: a reference image already carries a photographic character, so layering a style preset on top is contradictory.

In practice this means you choose one of two photographic strategies per request: prescribe the look (style) or supply the look (image_url). If your pipeline needs both — a reference product shot and a specific film look — generate with the reference first, then treat the look as a follow-up edit through image-to-image.

Keep seed fixed while you compare styles. Changing one variable at a time is the only way to learn what the enum actually does for your subject matter, and reproducibility makes that comparison cheap.

Use Case 3: Reference-Guided Composition Without Editing

Sometimes you have a reference image but you are not editing it. You want a new image that borrows its scene, palette, or arrangement. That is the image_url parameter on text-to-image: an optional public image URL used as a visual reference for the prompt's scene.

The distinction from image-to-image is intent. With image_url, the prompt still drives generation; the reference informs it. With image-to-image, the input image is the subject and instruction says what to change. If your request reads like "make something new that feels like this," use image_url. If it reads like "change this," use image-to-image.

Why this beats a full edit

An edit is anchored to its source. If you want a fresh composition that merely echoes a reference — a different camera angle, a rearranged scene, a new subject in a familiar setting — an edit will keep pulling you back toward the original pixels. Reference-guided text-to-image gives the model room to compose while still respecting the reference.

Implementation notes:

  • image_url takes a single public URL with a minimum length of 1. Hosting must be publicly reachable; there is no upload path implied by the parameter.
  • image_url and style are mutually exclusive. Pick reference or style preset.
  • prompt remains required and is still the primary instruction. Write it as if the reference were an attachment to the brief, not a replacement for it.
  • Pair with seed when you are iterating on prompt phrasing against a fixed reference, so differences you observe come from the prompt.

A common workflow: a brand supplies a mood board image, you generate twenty on-brief variants with one fixed reference and shifting seeds, then shortlist. Each variant is a single per-image call, so a twenty-variant sweep is twenty calls — predictable and easy to cap.

Use Case 4: Single-Image Edits and Masked Retouching

This is the image-to-image route at its most precise: exactly one image in image_urls, an instruction, and optionally a mask_url.

The mask convention is the one detail worth memorizing. White marks the area to edit. Black is kept. There is no inversion flag. The mask must also match the image size — a mask that does not line up with the source will not do what you expect.

Two constraints define the boundary of this feature:

  • mask_url is valid only for single-image edits, meaning image_urls must contain exactly one entry. Add a second reference and the mask has no defined meaning.
  • A single-image edit always keeps that image's ratio. Passing aspect_ratio here does not buy you a reframe; the source ratio wins.

When to mask and when to instruct

Masking is for locality. Use it when the change is confined to a region and everything outside must survive untouched — swapping a product label, replacing a background patch behind a subject, removing a small object from a set.

Instruction alone is for changes that are allowed to ripple. "Make the lighting warmer" or "turn this into a winter scene" will legitimately alter the whole frame, and a mask would fight that.

A retouching loop that holds up

  1. Fix seed for the edit session.
  2. Fix the source image and the mask.
  3. Iterate only on instruction wording.
  4. When a wording wins, store the triple — source, mask, instruction — plus the seed.

Because the same seed and inputs reproduce the same result, that stored triple is a reproducible recipe. You can regenerate the approved output months later, or run the same recipe across a batch of near-identical source images with confidence that the only moving part is the input.

Keep in mind every one of these calls is a billed image, including the ones you reject during prompt iteration. Cap your loops.

Use Case 5: Multi-Image Variations and Referenced Recomposition

The image_urls array accepts 1 to 4 public URLs, and order is meaningful: the first image is the one to edit, the remaining up to three are references. The instruction can address them positionally as <image_1>, <image_2>, <image_3>, and <image_4>, in that order.

That positional addressing is what makes multi-image work controllable. Instead of vague instructions like "use the style from the other one," you write instructions that name their targets:

  • "Place the object from <image_2> into the scene of <image_1>, matching its lighting."
  • "Recolor <image_1> to match the palette of <image_3>."
  • "Replace the background of <image_1> with the setting of <image_2>, keeping the subject of <image_1> unchanged."

How aspect_ratio behaves here

This is where the ratio rules get interesting. If you omit aspect_ratio on image-to-image, the output follows the first image. If you pass aspect_ratio, it overrides — except in the single-image case, where the source ratio is always kept.

So in a multi-image request you have a real choice: inherit <image_1>'s framing by staying silent, or impose a new frame by naming a ratio. Imposing is useful when your downstream layout is fixed and the source images are not. Inheriting is useful when the edit should be invisible in a pipeline that expects stable dimensions.

One caveat: mask_url is not available here. Masked retouching is a single-image feature, so multi-image recomposition relies entirely on instruction clarity.

Sequencing multi-image work

Start with two images. Add references only when you can name precisely what each contributes. A four-image request with an under-specified instruction is four times the ambiguity, and each attempt is a billed image. Build the composition incrementally: get <image_1> plus <image_2> right, fix the seed, then introduce <image_3>.

Implementation Notes: Seeds, Ratios, and Cost Control

Seed is your reproducibility contract

seed is an integer from 0 to 2147483647, defaulting to 5555. The same seed with the same prompt — or the same seed with the same inputs on the edit route — reproduces the same image. Treat it as a first-class part of your request record, not a debug field.

In production this gives you three things: deterministic QA (a stored seed plus stored inputs regenerates a known result), fair A/B comparison (vary one parameter, hold the seed), and safe retries (a retry with the same seed is a clean repeat rather than a new roll of the dice). If you want variety, change the seed deliberately and record which values you shipped.

aspect_ratio is an output contract

The output is about one megapixel across the entire enum. That is the design constraint to plan around: you are choosing a shape for a fixed pixel budget, not choosing a resolution. Pick the closest ratio to your target placement instead of generating square and cropping later — cropping throws away pixels you already paid for and can cut the subject.

On text-to-image, aspect_ratio defaults to 1:1. On image-to-image it follows the first input image when omitted, and a single-image edit always keeps the source ratio. Always set it explicitly in text-to-image pipelines; the default will surprise you otherwise.

Parameter conflicts to encode as validation

Three combinations are invalid and worth rejecting client-side before you spend a call:

  • style together with image_url on text-to-image.
  • mask_url with more than one entry in image_urls.
  • mask_url whose dimensions do not match the source image.

Also enforce the documented string limits: prompt and instruction require a minimum length of 1 and allow up to 10000 characters. image_urls requires between 1 and 4 items.

Cost control at a flat per-image rate

Billing is per image, and the official rate is $0.0572 on both routes. Since there is no cheaper preview tier, cost control is about call volume discipline, not parameter tuning:

  • Cap iteration loops. Prompt iteration on the edit route bills every attempt. Set a hard ceiling per creative and log rejections.
  • Generate thumbnails on your side. Downscale for review UIs locally; do not spend a full call to get a small version.
  • Make the seed the retry key. Retrying with a changed seed produces a different image and a second charge; retrying with the same seed is a deliberate repeat.
  • Batch by ratio. Group placements by aspect_ratio so each ratio gets one call per creative, not one call per placement.
  • Track cost per accepted asset, not per call. The gap between attempts and approvals is your real efficiency number, and it is the one worth optimizing.

Start on the text-to-image route for net-new visuals, move to the image-to-image route when pixels already exist, and keep the seed in your database from day one.

From request parameters through a reproducible seed loop to one billed output image.

Похожие статьи

Все статьи →

Начните работать с постоянными артефактами ИИ

Получите API-ключ и вызывайте модели изображений, видео и аудио через один API на основе tasks.

Читать документацию API