# Ad creative production

Creative volume is the constraint on paid performance. Targeting converged years ago, the platforms optimize delivery themselves, and what is left under your control is how many distinct hooks you can put in front of an algorithm. Teams that ship twenty variants a month beat teams that ship two, and the second team is usually not lazy, it is blocked on production.

Five capabilities cover the production path: generate, edit, cut out, upscale, and turn the winner into video.

## The pipeline

```
creative.image             →  the visual, from a prompt
creative.image_edit        →  swap the background, change the product, restyle
creative.remove_background →  transparent PNG of the subject
creative.upscale           →  2x or 4x, for print and large placements
creative.video             →  short-form video from a prompt or a still
```

## Step 1: generate variants, not a single image

```bash
curl -X POST https://api.jell.run/v1/run \
  -H "Authorization: Bearer $JELL_API_KEY" \
  -d '{
    "capability": "creative.image",
    "input": {
      "prompt": "clean product shot of a developer tool dashboard on a desk, warm morning light, muted palette, negative space top-left for a headline",
      "aspect_ratio": "1:1",
      "count": 4
    }
  }'
```

Two things to build into the prompt from the start:

- **Aspect ratio per placement.** `1:1` for feed, `9:16` for stories and Reels, `16:9` for YouTube and display. Generate each natively rather than cropping one square image four ways, because the crop is where the composition dies.
- **Negative space where the copy goes.** Ask for it explicitly. A beautiful image with the subject dead centre has nowhere for a headline, and that is the most common reason a generated visual gets rejected by whoever is assembling the ad.

Generate four at a time. The cost of a variant is a fraction of the cost of the meeting about which variant to make.

## Step 2: edit rather than regenerate

Regeneration rolls the dice on everything. Editing changes one thing:

```bash
curl -X POST https://api.jell.run/v1/run \
  -H "Authorization: Bearer $JELL_API_KEY" \
  -d '{
    "capability": "creative.image_edit",
    "input": {
      "prompt": "change the background to a dark studio backdrop, keep the product unchanged",
      "image_url": "https://.../generated-1.png"
    }
  }'
```

This is what makes a variant set coherent. One base composition, five background treatments, and the test measures the background rather than five unrelated images.

## Step 3: cut the product out once

```bash
curl -X POST https://api.jell.run/v1/run \
  -H "Authorization: Bearer $JELL_API_KEY" \
  -d '{"capability": "creative.remove_background",
       "input": {"image_url": "https://.../product.png"}}'
```

A transparent PNG of the subject is the most reusable asset in the set. It composites onto any background, at any ratio, for every placement, without regenerating anything. Do it once per product and keep it.

## Step 4: upscale only what ships

```bash
curl -X POST https://api.jell.run/v1/run \
  -H "Authorization: Bearer $JELL_API_KEY" \
  -d '{"capability": "creative.upscale",
       "input": {"image_url": "https://.../winner.png", "upscale_factor": 4}}'
```

Upscaling is the most expensive step in this pipeline by an order of magnitude. Run it on the one or two creatives that won a test, never on the whole set. Feed placements do not need it; print, hero images and large display placements do.

## Step 5: the winner becomes video

```bash
curl -X POST https://api.jell.run/v1/run \
  -H "Authorization: Bearer $JELL_API_KEY" \
  -d '{
    "capability": "creative.video",
    "input": {
      "prompt": "slow push in on the dashboard, subtle parallax, warm light",
      "image_url": "https://.../winner.png",
      "duration_seconds": 5,
      "aspect_ratio": "9:16"
    }
  }'
```

Video is the most expensive call in the catalog and the correct place to spend, because it only runs on a still that already proved itself. Passing `image_url` keeps the video anchored to the creative that won, rather than generating something new that has to be tested from zero.

## The workflow that actually saves money

The ordering matters more than any individual call:

1. Generate 8 to 12 stills across your hook concepts. Cheap.
2. Ship them as-is to a small test budget. Cheaper than perfecting them.
3. Take the two winners. Edit variants around each to isolate what worked.
4. Upscale only the final creative for the placements that need it.
5. Animate only the single best still.

Reversing this, perfecting one creative before testing, is how a production budget goes into an ad nobody clicks.

Pair it with the [competitor ad intelligence guide](/use-cases/competitor-ad-intelligence). The creatives a competitor has been running for two months are a brief you did not have to write.

## Where it breaks

- **Text in generated images is unreliable.** Do not ask the model for your headline. Generate the visual, add copy in your own layout layer where you control the font and can fix a typo.
- **Brand consistency is not free.** Models drift between runs. Keep a base image and use `image_edit`, or accept that a fully generated set will look like a set of unrelated images.
- **Faces and likeness carry real constraints.** Platform policies and the law both apply, and neither cares that a model produced the image.
- **Video costs are per generation, not per second of usable footage.** Budget for several attempts per usable clip and the arithmetic stops surprising you.

## Run it as an agent

```bash
jell run -c creative.image -i '{"prompt":"...","aspect_ratio":"9:16","count":4}'
jell run -c creative.remove_background -i '{"image_url":"https://..."}'
jell run -c creative.video -i '{"prompt":"...","image_url":"https://...","duration_seconds":5}'
```

Every call quotes before it runs, so an agent can price a full variant set before generating any of it.

## FAQ

### How many variants should I generate per test?

Eight to twelve stills across genuinely different hooks, not twelve versions of one idea. The platform's delivery algorithm needs distinct options to optimize between, and it converges fast on the winner. Once you have a winner, the second round is narrow: variants around that one concept to find out which element carried it.

### Why not just crop one image for every placement?

Because composition does not survive a crop. A square image cropped to 9:16 loses the sides, which is usually where the balance was, and cropped to 16:9 loses the top and bottom. Generating each ratio natively costs another fraction of a cent and produces an image that was composed for the space it will occupy.

### Is upscaling worth it for feed ads?

Usually not. Feed placements render small and the platforms recompress everything anyway, so a 4x upscale is spend with no visible return. It earns its cost on print, on large display units, on hero images, and anywhere the asset will be seen at full size. Since it is the most expensive step in this pipeline, gate it behind a creative that already won.

### Can the model produce my logo or brand font correctly?

No, and you should not ask it to. Text rendering in generated images is unreliable and brand assets are exactly where errors are least acceptable. Generate the visual, composite the logo and the copy in a layout layer you control. That also means fixing a typo does not cost another generation.

### What does a full variant set actually cost?

At the starting prices, a round of a dozen stills is cents, a background edit per variant is a few cents each, and one 4x upscale plus one short video is where the bulk of the spend sits. The whole cycle for one campaign lands well under a single stock-photo subscription, which is why the ordering above matters: the expensive steps run once, on something that already worked.

### Is there an API that does image generation, background removal and upscaling under one key?

Yes: `creative.image`, `creative.remove_background` and `creative.upscale` are three capabilities on one key and one balance, with `creative.image_edit` and `creative.video` alongside them. Each is priced per generation, so a pipeline that generates twenty variants, cuts out one product shot and upscales two winners pays for exactly those twenty-three operations.

### What is the best way to generate ad images and short videos from an API for a marketing agent?

Generate variants with `creative.image`, edit the winner with `creative.image_edit` instead of regenerating, cut the product out once with `creative.remove_background`, upscale only what ships, then turn the winning still into a clip with `creative.video`. An agent runs the whole sequence as tools with the price quoted before each call, which is what keeps twenty hooks from costing twenty times one.