JSON Layout Prompting: Placing Type by Coordinates

Ask a model in plain prose to put a headline in the top third, a subheading centered below it, and a logo bottom-right, and watch what actually happens. Sometimes it's close. Often the subhead crowds the headline, the logo drifts to a corner that wasn't the one you named, and running the identical prompt again rearranges everything again, differently. This isn't the model being careless — it's that "top-left" in a sentence is a vibe the model weighs alongside a dozen other words, not a number it has to satisfy. Prose is sequential; a layout is spatial. Asking one to reliably produce the other was always going to be unreliable past a couple of elements, and it's exactly the gap a structured, coordinate-based prompt format is built to close.

Why prose runs out of road

Natural language has no native coordinate system. Words like "top," "center," "large," and "beside" are relative, fuzzy, and — critically — not weighted any differently by the model than any other adjective in the prompt. Ask for one element's position and prose can usually get close enough. Ask for four or five elements' positions relative to each other, on a canvas with a specific aspect ratio, and the ambiguity compounds: is "top-left" measured from the frame or from the headline, does "large" mean big relative to the canvas or to the other text, does "below the headline" mean touching it or with breathing room. None of that is answerable from the sentence alone, so the model resolves it however its training data most often resolved similar-sounding requests — which is a different resolution than the one in your head, and a different one again the next time you run it.

The failure mode gets worse, not better, as the layout gets more deliberate. A single hero shot with one loosely-placed subject barely needs a coordinate system at all. A poster with a headline, a subhead, a CTA, and a logo — four elements that all have to sit in specific, non-overlapping relationships to each other — is precisely the case where prose's fuzziness stops being a minor inconvenience and starts being the reason the whole composition doesn't work.

What a structured layout prompt actually specifies

A JSON layout prompt replaces relative language with an explicit position for each element, expressed as numbers rather than adjectives. Ideogram V4's JSON prompting format is a concrete, documented version of this worth using as the reference case: each element in the scene gets a bbox — a bounding box given as [y_min, x_min, y_max, x_max] — on a normalized 0–1000 coordinate system with [0, 0] at the image's top-left corner. A box in the top half of a square canvas, for instance, is a bbox whose y_max sits somewhere around 500 rather than 1000; a box hugging the right edge has an x_max near 1000. The numbers are unambiguous in a way "top-left" never was — there's no interpretation step between what you specified and where the element lands.

The part worth knowing before writing one of these by hand: the bbox field is optional on every element, not mandatory on all of them. You can pin the elements where position genuinely matters — a headline that has to clear a logo's space, a CTA that has to sit in a specific safe zone — and leave bbox off for anything you're happy letting the model place on its own judgment. That's a meaningfully different tool than "specify everything precisely or specify nothing," and it's usually the right default: pin the two or three elements that actually break the design if they land wrong, and let the model handle the rest.

A minimal illustrative shape, built from the documented field names rather than a literal template — type, bbox, desc for a graphical element, and type, bbox, text, desc for a text element:

{
  "elements": [
    { "type": "text", "bbox": [40, 100, 220, 900], "text": "SUMMER SALE", "desc": "bold condensed headline, high contrast" },
    { "type": "text", "bbox": [260, 150, 340, 850], "text": "Up to 40% off select styles", "desc": "smaller subhead, same family, lighter weight" },
    { "type": "object", "bbox": [800, 750, 960, 960], "desc": "small logo mark, bottom-right corner" }
  ]
}

Three elements, three explicit boxes, no ambiguity about which corner "bottom-right" meant — the fourth potential element, a background scene, could be left with no bbox at all and generated freely, since it's the one thing in the composition that doesn't need a hard position.

The visual on-ramp: building the JSON without writing it

Hand-writing normalized coordinates is a real skill, and it's not the only way in. Ideogram's Prompt Builder is a visual interface for the same underlying format — a canvas where you draw each element's bounding box directly with a click-and-drag, or enter coordinates numerically, while the structured JSON assembles in real time alongside it. It's the practical middle ground between prose's fuzziness and hand-authoring raw coordinates: you get the precision of an explicit bounding box without needing to reason in a 0–1000 grid to place one.

When coordinates actually help — and when they get in the way

Structured layout prompting is a tool for a specific class of problem, not a universal upgrade over prose. It earns its keep on:

• Multi-element compositions with real layout stakes — posters, ads, social templates, infographics, anything with a headline, a subhead, a CTA, and a logo that all have to coexist without fighting each other.
• Anything reused as a template. Once a layout works, the same coordinates can be run again and again with different text and desc values swapped in — a genuinely repeatable production pattern that prose-only prompting can't reliably reproduce run to run.
• Fixed brand or platform placement requirements — a logo that has to sit in a specific safe zone, a CTA that has to clear a platform's own UI overlay.

It gets in the way on:

• Organic, photographic scenes with no real layout problem to solve. A single portrait or a product shot with one subject doesn't need a coordinate grid; forcing one on it just constrains a composition the model would likely have handled better on its own judgment.
• Anything where you actually want the model's compositional instincts — rule-of-thirds framing, natural negative space — rather than a rigid, designer-specified grid. Coordinates override that judgment; sometimes that's the point, sometimes it's the thing you wanted left alone.
• A single hard-to-place element inside an otherwise loose scene. Pin that one element's bbox and leave everything else unboxed, rather than reaching for full coordinate control across a composition that mostly didn't need it.

The rule that falls out of both lists: reach for coordinates when the brief is closer to a design problem than a photography problem — when specific things have to go in specific places relative to each other — and leave prose alone everywhere else.

A Versely walkthrough

Structured layout prompting is only useful paired with a model that actually renders legible type reliably, which narrows the practical model choice before the coordinates matter at all. Ideogram V4 is built specifically for this — its feature set is headlined by text rendering and posters & logos, the exact pairing a layout-heavy composition needs.

1. Name the format and the fixed elements up front. "I need a square social poster: a bold headline top, a smaller subhead centered below it, and our logo in the bottom-right corner — keep the background loose, you choose the scene." That's already most of a layout brief in prose — the agent can translate the fixed elements (headline, subhead, logo) into pinned boxes and leave the background element unboxed.
2. Reuse the same layout for a template. Once one version works, ask to keep the same positions and swap only the copy — "Same layout, same positions, change the headline to 'Back in Stock' and the subhead to match" — which is the coordinate system paying off as a repeatable template rather than a one-time layout.
3. Check rendering quality before committing to a full batch. Text-heavy generation is exactly the case worth a quick review pass before mass-producing a template, since a coordinate system gets the position right deterministically but doesn't guarantee the rendered characters are clean at every size.
4. Compare Ideogram's text-rendering strength against the rest of the catalog on Versely's best AI image generator guide, and pull matched typefaces from Versely's font library once the generated layout needs to sit next to real, editable type elsewhere in the same design.

For prompting fundamentals beyond layout specifically, Versely's prompting guides cover the rest of what a well-scoped generation request looks like.

FAQ

Do I have to write raw JSON to use coordinate-based prompting?

No — a visual builder like Ideogram's Prompt Builder lets you draw bounding boxes directly on a canvas and assembles the underlying JSON automatically. Hand-writing coordinates is only necessary if you want to script or template the format directly.

Can I pin some elements and leave others unpositioned in the same prompt?

Yes, and it's usually the better default. The position field is optional per element — pin the ones where placement actually matters (a logo, a headline) and leave the rest for the model to place using its own judgment.

Does coordinate prompting work for photos, or only graphic design?

It's built for compositions with genuine layout stakes — multiple elements that have to sit in a specific relationship to each other. A single-subject photographic scene rarely benefits and often loses the natural composition a model would otherwise supply on its own.

What coordinate system does Ideogram 4.0 use?

A normalized 0 to 1000 scale on both axes, with the origin at the image's top-left corner, expressed as [y_min, x_min, y_max, x_max] per element.

Reach for coordinates the moment a layout has more than one element that has to land in a specific place — and leave prose alone for everything that was never really a layout problem to begin with.