Gemini image prompts: eight fields, one and a half you can fill

An image to prompt line fills one field of a Gemini image request, and half of a second one. Across 160 long lines generated from 40 real files, every line lands in the text part of input — 160/160 — and none of them can reach the image part of that same input: 0/160, because the tool reads your picture and never hands it back. Of the seven fields left, aspect_ratio is reachable in 40 lines out of 160, all of them Midjourney, and the other six sit at 0. Attached to the picture it came from, that line is a median of 216 characters, and the median request built around a long Stable Diffusion line is 324,746: 0.065% of what you send.

Every count below is arithmetic on 480 lines, not on a Gemini response. Forty PNGs — 39 photographs at 640 × 360 and one code screenshot at 800 × 450 — were decoded here and box-downsampled to 192 × 192, 36,864 cells at any file size, then written into four shapes at three lengths: twelve lines per file, 480 in all. Gemini is none of those four shapes — those are Midjourney, Stable Diffusion, Flux, DALL·E — so no request was sent and no image came back. The eight field names and their accepted values are read from Google’s cookbook notebook, and they are the reference this page measured against rather than data of ours. Base64 length is 4 × ceil(bytes / 3), the encoder’s own rule.

Here is a whole request for one file, with the base64 blob cut to 48 characters. Everything else is exactly what was measured:

{
  "model": "gemini-3.1-flash-image",
  "input": [
    {
      "type": "text",
      "text": "widescreen 16:9 composition, well-lit, balanced exposure, dominant palette of silver, tan, grey, charcoal, moderately saturated colour, slightly warm tone, medium contrast, highly detailed with intricate texture, evenly lit, brighter upper half, bright and uplifting atmosphere --ar 16:9"
    },
    {
      "type": "image",
      "data": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx…",
      "mime_type": "image/png"
    }
  ],
  "generation_config": {
    "image_generation_config": {
      "aspect_ratio": "16:9",
      "image_size": "1K"
    }
  },
  "response_modalities": [
    "text",
    "image"
  ]
}

The text part is 0.065% of the request

A Gemini image request carries the picture and the words in the same array, as two parts of one input. The two are not comparable in size. The forty files run from 22,834 to 489,354 bytes — a 21.4fold spread — and base64 inflates each by 1.333 to between 30,448 and 652,472 characters. The generated line runs from 90 to 357 characters, 14 to 47 words. Set one against the other and the line is a rounding error.

Taken over all 480 rows rather than as twelve medians, the share runs from 0.016% to 0.921%, median 0.065%, and the image part is between 108 and 6,177 times the text part, median 1,535×. The two extremes are arithmetic, not judgement: 0.921% is the smallest file in the set — 22,834 bytes — paired with the longest of its twelve lines, 283 characters of Stable Diffusion; 0.016% is a 477,186-byte file paired with the shortest of its twelve, 103 characters of DALL·E. Nothing you do to the line moves that share by much, and the fourth section shows why.

The practical reading is blunt. If you take a picture, run it through an image to prompt tool, and send the result to Gemini without the picture, you are sending 216 characters and withholding 324,050 of them. The tool measured the file; it did not keep it.

Eight fields, one and a half you can fill

The request has eight top-level fields, one of which — input — takes two kinds of part. Each row below was tested against the 160 long lines, forty files at four shapes. “Filled” means the field’s value can be read out of the line itself.

The half-filled field deserves the detail. aspect_ratio is filled in 40 of 160 lines and every one of them is a Midjourney line, because that is the only one of the four shapes that appends a ratio as a parameter, as the --ar 16:9 tail on the sample request above. The value it carries is 16:9, which is one of the fourteen official values, so on this corpus the field is reachable a quarter of the time and wrong never. The other 120 lines still contain the ratio, but inside the framing phrase as ordinary English — widescreen 16:9 composition — which is a description, not a parameter.

Two of the zeros are worth separating out, because both look like hits until you check what the word is doing. The word image appears in 80 of the 160 lines, all of them Flux or DALL·E: A widescreen 16:9 image. That is a noun inside a sentence, not the response_modalities flag, which has to be set outside the text. And across all 480 lines the only number-shaped token that ever appears is 16:9 — so there is no pixel dimension anywhere in the output for image_size to read, and nothing that could carry a duration or a reference frame on the video side either. That is the whole of what the line can say about sora-style requests too: one line of text, no number in it but the ratio.

Counted the same way against a video request, the line does worse rather than better: eleven fields, and it fills one of them. That count — eleven fields, 480 lines, nine of them with nothing to read — is on what one generated line hands a video model.

What you type yourself: a constant 373 characters

Strip the prompt and the base64 out of the request and what remains is a skeleton that does not vary. Build the request around each of the 160 long lines and the part you have to supply yourself is 373 characters on all four shapes, to the character: the model name, the two part wrappers, the ratio, the size, the modality list. What varies is only how much of the result is yours.

Read the two shares together and the shape of the job appears. On a text-only request the generated line is between 35.2% and 48.9% of what you send, depending on shape and file. Attach the picture and it falls to between 0.034% and 0.91%. Same line, same model, two different jobs: with the picture, the words are a caption on evidence; without it, they are all the evidence there is.

Which brings us to what actually decides the size of the request. It is not the line.

The correlation between file size and request size is 1.000 to three decimals — the file, once encoded, is the request. The correlation between a file’s median line length and its request size is 0.115. Take a single file and swap its shortest of twelve lines for its longest and the request grows by 0.03% to 0.58%, median 0.06%. Choosing a longer output shape changes what you send by less than one per cent; choosing a bigger photograph changes it by a factor of twenty-one.

Forty files, 480 lines, 373 characters that are yours

The counting above is reproducible from the notebook this page was built with: forty PNGs decoded with the zlib inflater, box-downsampled to 192 × 192, measured by the same analyze and describe the live tool runs, composed into 480 lines by the same compose. Request sizes are JSON.stringify of the exact structure shown at the top of the page, with the base64 field filled with a placeholder string of the measured length rather than real bytes. No request was sent.

Three things follow for anyone building a Gemini image prompt from a picture.

Attach the picture. The image part is 0/160 from the tool and it is the part that carries between 108× and 6,177× more characters than the words do. Sending the line alone throws away the only half of the request that has the picture in it.

Set the size yourself, in the field, not in the words. image_size is 0/160 from the line and the line contains no dimension of any kind. Writing “4K” into the prompt is prose the model may or may not honour; the field is enforced.

Pick your shape for the ratio, or type it. aspect_ratio is filled by 40 of 160 lines — the Midjourney ones — and by none of the others. On the other three shapes the number is in the request only if you put it there.

What is left is a request with two parts that disagree in scale by three orders of magnitude: a measured caption of 216 characters and a picture of 324,050. If you want to know what the caption actually says about that picture, what this tool measures is the thirteen-row signal table behind it, and how much of your picture survives counts what is lost on the way. For the ratio field specifically, the Nano Banana page lists which of a model’s official aspect tiers this tool can and cannot write, and getting a usable prompt from any picture covers the edits that come after the line is generated.