Aspect Ratio Is a Contract: Auditing Ten Image APIs for True Vertical Output
Photo: Krzysztof Popławski, CC BY-SA 4.0, via Wikimedia Commons
A 9:16 image is not just a picture that happens to be tall. On a phone, it is a layout with rules: a face near the top can disappear under platform chrome, feet near the bottom can get clipped by a caption bar, and a subject that sits dead center in a square render can feel off-balance once the frame goes vertical. So when an image API says it supports vertical output, the useful question is not whether the result looks tall. It is whether the file that comes back can survive a real mobile feed.
For this 2026 field test, we sent the same vertical brief to ten hosted image-generation APIs. We asked for a full-body streetwear portrait, centered subject, generous headroom, clean footroom, no text, and an explicit 1080x1920 canvas. Where an endpoint exposed an aspect-ratio or width/height parameter, we used it. Where it only accepted prose, we put the dimensions in the prompt and hoped for the best. Then we audited what actually arrived.
The test: one brief, ten endpoints
We kept the creative brief boring on purpose. Same subject description, same lighting, same background. For each API, we captured the returned file, the API response body, and any available metadata: revised prompt, seed, model version, safety flags, and provenance fields. We also overlaid a phone-safe-zone grid and checked where the head, shoulders, waist, and feet landed.
We are labeling the services A through J here because the point is not to dunk on any one vendor. The point is to show how often the word vertical means something different on the API side than it does on the creative side.
What 9:16 actually meant
Only four of the ten endpoints returned exactly 1080x1920 when we asked for it. Three returned a close-but-not-quite vertical size, such as 1024x1792 or 896x1600. One returned 1080x1350, a 4:5 frame that is vertical-ish but not the ratio we requested. One returned a 1080x1920 file that contained a square render centered inside blurred bars. And one ignored the vertical request entirely and handed back 1024x1024.
That last result is the one that stings in production. A 1:1 file can be cropped to 9:16, but the model did not compose for that crop. The subject may be too wide, the headroom may be wrong, and the feet may already be touching the bottom edge. If your pipeline blindly crops, you are not fixing the composition. You are gambling with it.
A useful audit therefore starts with file inspection, not visual vibes. Check the pixel dimensions before anything else. Then check whether the image is a true render or a padded composition. Blurred bars and solid-color side panels are easy to miss in a thumbnail and expensive to discover after a batch has shipped.
Subject placement is where vertical promises break
Even some endpoints that returned the right dimensions failed the mobile layout test. In several outputs, the top of the head sat inside the upper 10 percent of the frame, which is exactly where app navigation and status UI tend to live. In others, the feet were technically present but only by a few pixels, making the image feel cropped even when the file was tall enough.
This is not a model-quality problem in the abstract. It is a composition-contract problem. Many image models are trained on a wide mix of aspect ratios, and a square-friendly composition often leaks into vertical requests. The subject ends up centered like a product shot, with equal empty space above and below. That can look fine on a desktop preview and awkward on a phone.
Prompt language helps, but it is not a guarantee. Asking for headroom, footroom, and a full-body frame is reasonable. Asking the API to respect a specific safe zone is better. Getting an endpoint that accepts explicit canvas controls and returns predictable framing is better still.
Cropping is a second model in your pipeline
The most common production mistake we saw was treating the API output as the final frame. It usually is not. Teams often generate a larger or squarer image and then crop to 9:16 downstream. That means a second system, sometimes a simple script and sometimes an auto-crop model, is making composition decisions after the image model has already finished.
If you must crop, test the crop before you scale the workflow. Generate a contact sheet at phone size. Look for heads that get clipped, hands that leave the frame, and logos or text that drift under platform UI. The crop should be a planned part of the brief, not a cleanup step that happens because the API returned the wrong shape.
Metadata tells on itself
The metadata audit was just as revealing. Some responses included a revised prompt that quietly changed the framing language. Some included seeds and model identifiers; others did not. Provenance fields were inconsistent. A few files carried content credentials. Several had stripped EXIF data. If your team needs reproducibility or platform disclosure, you cannot assume the API response will give you a clean paper trail.
Our rule after this test is simple: log what the API returns, then add your own record. Capture endpoint, model version, requested dimensions, returned dimensions, seed if available, prompt, timestamp, and any post-processing steps. If provenance metadata is missing, add it at ingest. The file should be able to explain itself later.
A vertical-first checklist
Before you wire another image API into a mobile workflow, run this checklist:
- Treat aspect ratio as a required output field, not a creative suggestion. Validate returned pixels against your target before the asset enters review.
- Prefer endpoints with explicit width, height, or aspect-ratio parameters. Prompt-only control is a coin flip with better branding.
- Reject padded outputs unless padding is part of the design. Detect blurred bars, solid fills, and letterboxing.
- Compose for phone safe zones. Keep faces and key details out of the top and bottom bands where app UI tends to sit.
- Ask for headroom and footroom in the prompt, then verify it visually. Do not assume the model honored the request.
- Test the downstream crop. If you generate square and crop vertical, inspect the crop at phone size before scaling.
- Audit metadata on ingest. Record dimensions, model version, seed, revised prompt, and provenance status.
- Build a contact sheet for every batch. A grid of tiny vertical frames catches bad framing faster than a folder of full-size files.
The contract is the file
A 9:16 promise is kept by pixels, not by prompt language. The API can say it supports vertical output. The model can produce something that looks tall in a preview. But the production contract is the returned file: its dimensions, its composition, its crop behavior, and its metadata.
Ask for vertical, then verify vertical. That habit will save more time than any prompt tweak, and it will keep your mobile feed from discovering the difference for you.