● tokenstore

Turning a One-Line Idea into an Adult Storyboard

How Nureta's AI adult storyboard generator turns a single line of idea into a titled 剧本 — cast plus per-scene setting, beat, and duration — then hands it off to the video renderer.

3 min read

An adult storyboard — a 剧本 — is the shot list before the shoot: a titled plan that names the cast and breaks the story into scenes, each with its own setting, beat, and running time. Nureta's generator builds one from a single line of idea, so you can see the whole shape of a scene before a single frame is rendered.

It is the same v3 scene director that drives the video pipeline, stopped one step early: it writes the plan and hands it back as text instead of rendering. That makes storyboarding fast and cheap — $0.01 flat per storyboard — and it means the plan you approve is exactly what the renderer will build.

What the generator actually makes

A storyboard here is structured data, not prose. You get a title, a characters list, and an ordered scenes array. Nothing is rendered — no character images, no video — so nothing is billed beyond the flat $0.01. It is a plan you read, edit, and only then commit to a render.

The one-line input

The generator takes exactly one text line: the premise. a courier delivers a package to the wrong penthouse is a complete input. You are not writing scene directions — you are handing the director a situation and letting it invent the cast, the settings, and the beats.

Give it a premise with a built-in reason for two people to end up together and it structures the scene well. Vague premises produce generic storyboards; specific ones produce specific arcs.

The output structure, field by field

  • title — a short name for the scene the director invented.
  • characters — the named cast, like Nadia and Rhys. These names anchor identity across every scene.
  • scenes[] — the ordered shot list; each entry carries index, setting, beat, and durationSeconds.
  • setting — where the shot happens, e.g. a rain-streaked penthouse window.
  • beat — what happens in the shot, written concretely; explicit shots spell out the act.
  • durationSeconds — how long that shot runs.

How length shapes the scene count

The optional duration field (5–180s, default 30) sets how much story the director writes — more seconds means more scenes and a longer arc — without changing the $0.01 price. Set it to the length you plan to render: the scene durationSeconds should sum to roughly the video you have in mind, so the storyboard maps cleanly onto the render.

Because the storyboard and the renderer share one director, what you approve is what gets built — the cast, settings, and explicit flags carry straight into the render instead of being re-guessed.

Generate a storyboard

curl -s -X POST "$TOKENSTORE_URL/api/v3/contents/scripts" \
  -H "Authorization: Bearer sk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seahorse-script",
    "duration": 45,
    "content": [
      { "type": "text", "text": "a courier delivers a package to the wrong penthouse" }
    ]
  }'
# poll GET /api/v3/contents/scripts/:id for content.script

The endpoint and its response shape are in the script API docs and retrieve a script task. No code? The playground renders the storyboard on screen.

From storyboard to video

The storyboard is designed to feed the renderer. Turn each scene into an advanced segments entry — {script, duration_seconds, explicit} — and the video path renders every shot and stitches them into one scene up to three minutes long, holding the cast consistent throughout. Or submit in edit mode to keep tweaking the draft before you pay. The mechanics of stitching many shots into one clip are covered in multi-shot adult scenes up to 3 minutes.

Where to go next

Open the playground →
Turning a One-Line Idea into an Adult Storyboard — Nureta Guides