JSON Prompts for AI Video (Veo 3 & Sora 2): Format & Examples

A "JSON prompt" for AI video is a plain-text prompt written as a structured object — subject, action, camera, lens, lighting, style and more — instead of one long sentence. It is genuinely useful for consistency and iteration. But there is one thing every honest guide has to say up front: neither Google Veo nor OpenAI Sora documents a JSON prompt schema. Both makers' official guides recommend natural-language prose; the JSON pattern is a community convention that works only because the models happily read well-organised JSON as text. This guide gives you the schema table, two copy-paste examples for Veo 3 and Sora 2, and a clear line between what the model parses and what it just reads.

What a JSON prompt for AI video actually is

It is an ordinary prompt written as a structured object rather than a run-on sentence. Instead of "a chef plating dessert in a warm kitchen, shot on a slow dolly-in with soft window light," you write the same information as named fields:

{
  "subject": "a chef plating a dessert",
  "action": "places a final berry, then wipes the rim",
  "camera": "slow dolly-in, eye level",
  "lighting": "soft window light, warm"
}

The model does not receive a parsed data structure — it receives that block as text. Video models like Veo and Sora are generous about formatting, so a tidy JSON string reads to them much like a well-punctuated paragraph. The value is on your side of the wire: named fields force you to specify each dimension of the shot, and they make a prompt easy to diff, template and reuse. If you are choosing a model first, our best text-to-video models of 2026 guide covers the field; this article is about the prompt format.

Do Veo 3 and Sora 2 officially support JSON prompts?

No — and this is the single most important fact to get right. Every primary source from the two makers uses natural-language prose and none documents a JSON prompt schema:

• OpenAI's Sora 2 Prompting Guide recommends prose. It offers an optional structured breakdown (Scene Description, Cinematography, Actions, Dialogue, Background Sound) but explicitly states this is "not a one-size-fits-all recipe for success" — a framework for consistency, not a required format, and never JSON.
• Google DeepMind's Veo prompt guide uses prose exclusively and lists prompt elements — shot framing and motion, style, lighting, character, location, action, dialogue — advising you to "use a mix of the elements" in descriptive language.
• Google Cloud's Veo 3.1 prompting guide gives a five-part prose formula — [Cinematography] + [Subject] + [Action] + [Context] + [Style & Ambiance] — with every example written as a plain text string, and no mention of JSON.

So where does JSON prompting come from? It is a community and vendor-blog convention. Templates with fields like version, global_style, continuity and a scenes array circulate on sites such as imagine.art and tenten — and even those sources concede there is "no secret JSON schema the model was trained to parse." The JSON works because the model tolerates it as well-organised text, full stop.

Why structure beats a plain sentence anyway

The benefit is discipline and repeatability, not parsing. A structured prompt buys you three concrete things a sentence does not:

• Coverage. Empty fields are visible. If your object has no lighting key, you notice — a prose prompt silently omits it and the model guesses.
• Diffability. Across a shot series you can keep every field fixed and change exactly one. OpenAI's guide encourages precisely this single-variable discipline — "same shot, switch to 85 mm" — which is far easier to express as a one-line field edit than by rewriting a paragraph.
• Reuse. A base object with a fixed global_style and continuity block, plus a per-shot action, is a clean template for a multi-shot sequence.

None of this requires the model to understand JSON as data. You get the same generation whether you feed it the JSON or the equivalent prose; the JSON just keeps you organised. That is the honest case for the pattern — and it is a good one.

The JSON prompt schema: a field-by-field table

Here is a synthesised schema that maps community field names to what the official prose guides actually list. Use it as a checklist; every field is optional and consumed as text. The right-hand column shows where each concept appears in Google's and OpenAI's own prose framework.

The last two rows are flagged for a reason, covered in its own section below: duration and aspect ratio are governed by API parameters, not by anything you write in the prompt. The prose-vs-JSON mapping above is drawn from Google Cloud's cinematography-plus-subject-plus-action-plus-context-plus-style formula.

Copy-paste JSON example: Veo 3

A ready-to-use object for a single Veo shot. Paste it as your prompt text. Remember the model reads it as a string — you can equally flatten it into a sentence and get comparable results.

{
  "subject": "a vintage red convertible",
  "action": "drives along a cliffside road, hair and scarf catching the wind",
  "camera": "aerial tracking shot, slowly pulling back to reveal the coastline",
  "lens": "wide angle, deep focus",
  "lighting": "warm golden-hour sun, long shadows",
  "style": "cinematic, 35mm film grain, saturated color",
  "context": "winding coastal highway above a turquoise sea",
  "mood": "free, exhilarating",
  "audio": "engine hum, wind, faint surf below"
}

To iterate the community way, copy the object and change one field — swap lens to "85mm, shallow focus" for a tighter, more intimate look while everything else stays fixed. Set the clip length and 16:9/9:16 frame as generation parameters, not inside this block.

Copy-paste JSON example: Sora 2

The same pattern, organised around Sora's optional storyboard breakdown. OpenAI's guide frames a good prompt like a storyboard beat sheet; this object simply names those beats. Feed it as the prompt string and set model, size and seconds separately in code.

{
  "scene": "a rain-slicked Tokyo alley at night, neon signs reflecting in puddles",
  "subject": "a woman in a translucent raincoat holding a paper umbrella",
  "cinematography": "medium shot, eye level, slow push-in; shallow depth of field",
  "actions": [
    "she steps forward and glances over her shoulder",
    "tilts the umbrella, revealing her face"
  ],
  "lighting": "magenta and cyan neon, wet specular highlights",
  "dialogue": "none",
  "background_sound": "steady rain, distant traffic, a passing train"
}

The field names here (scene, cinematography, actions, dialogue, background_sound) mirror the optional structure in OpenAI's Sora 2 Prompting Guide — but remember the guide presents that structure as prose, and calls it a framework for consistency, not a required schema. Once you have a look you like, hold every field fixed and change one action beat at a time. Costs for generating these clips are volatile and per-second; our Sora 2 cost breakdown has the current numbers.

What belongs in API parameters, not the prompt

Duration, aspect ratio and model choice are controls, not description — put them where the model reads them. This is where a lot of JSON templates mislead:

• Sora. The model, size / aspect ratio and seconds of duration are set as separate API parameters in code — not embedded in the prompt text.
• Veo. Clip durations are fixed values (commonly 4, 6, or 8 seconds) and aspect ratios are 16:9 (landscape) or 9:16 (portrait), set as generation parameters. Confirm the exact enum values against the current Vertex AI Veo API reference before you ship, as they change between versions.

You can still keep a duration key in your JSON as documentation for your own team, but understand it does nothing at the model — the API parameter governs the output. Writing "8 seconds" into a prompt string is not how you get an 8-second clip.

Build your own 'veo3 json prompt generator'

A "generator" is just a template — you can reproduce one in a few lines. Most online generators take your inputs, drop them into an object with popular field names, and hand back the string. There is no hidden schema being unlocked. Here is the whole idea:

def video_prompt(subject, action, camera, lens, lighting, style, context, mood, audio):
    import json
    return json.dumps({
        "subject": subject, "action": action,
        "camera": camera, "lens": lens,
        "lighting": lighting, "style": style,
        "context": context, "mood": mood, "audio": audio,
    }, indent=2)   # the model reads this string as text

If you want an LLM to draft the fields for you from a one-line brief, that is a legitimate use — and it is the kind of text task a gateway is good at. DataLLM Lab serves chat and text-to-image models on one OpenAI-compatible key, so you can generate the prompt object (and even storyboard frames with an image model) from the same endpoint. It does not serve Veo or Sora themselves — for the video generation step you call each maker's own API. For the image side, see the best AI image APIs of 2026.

FAQ