@@ -143,18 +143,18 @@ shotstack template delete <id>
 
 ### `shotstack models [id]`
 
-Lists the generation models for prompt-driven image, video and audio assets, with each one's price in credits and whether your API key can use it. A model your plan doesn't include shows why. Pass a model id to see the options it accepts.
+Lists the generation models for prompt-driven image, video and audio assets, with whether your API key can use each one. A model your plan doesn't include shows why. Pass a model id to see the options it accepts.
 
 ```sh
 shotstack models
-# → nano-banana-2  image  unavailable: AiCapabilityNotIncluded  credits per generation by resolution: 0.5K 0.375, 1K 0.5 (default), …
-shotstack models seedance-2.0-text-to-video    # price and the JSON Schema for its options
+# → nano-banana-2  image  unavailable: AiCapabilityNotIncluded
+shotstack models seedance-2.0-text-to-video    # the JSON Schema for its options
 shotstack models --output json
 ```
 
 ### `shotstack generate <model> <prompt>`
 
-Generates one image, video or audio asset from a prompt and prints its URL, without rendering an edit. `--options` takes the model's options as a JSON object (see `shotstack models <model>`). `--length` sets the clip length in seconds for models that generate to a duration. Generation is billed in credits on stage as well as v1. Identical requests share one job and its cached result, so repeating a request returns the same job instead of generating and charging again.
+Generates one image, video or audio asset from a prompt and prints its URL, without rendering an edit. `--options` takes the model's options as a JSON object (see `shotstack models <model>`). `--length` sets the clip length in seconds for models that generate to a duration. Generation is billed in credits on stage as well as v1; `--quote` prints what that exact request would cost, without generating or charging. Identical requests share one job and its cached result, so repeating a request returns the same job instead of generating and charging again.
 
 ```sh
 shotstack generate nano-banana-2 "A ceramic mug on a walnut desk, soft window light" --watch
 
@@ -24,7 +24,7 @@ If a check fails (no network, no npm, a sandbox), skip it and carry on.
 
 **Open-ended first render? Ask before composing.** If the ask doesn't state what the video is (subject, format or destination) — e.g. "render my first video", "make me a video", "set up Shotstack" — read [`references/onboarding.md`](references/onboarding.md) and ask its discovery questions, then WAIT for answers. Do not write an Edit first. An open-ended ask is not a specification, and a stray JSON file in the project doesn't make the user experienced. Compose without asking only when the user has stated what the video is, or explicitly says to just show anything.
 
-Commands for the Shotstack video rendering API. `render` submits an Edit JSON and returns a render ID; `status` polls a render until done. `ingest` uploads your own local files (or fetches remote URLs) and hosts them so they can be referenced from an Edit. `validate` lints an Edit — run it before every render. `studio` opens an edit in the browser editor for a human to preview, tweak, and render. `template list|get|create|update|delete` reads and writes templates saved to the account: `list` shows saved templates (id + name); `get <id>` fetches a saved template's Edit JSON (e.g. one the user designed in Studio) so you can render or remix it; `create <file> --name <name>` saves an edit as a new template; `update <id> <file>` overwrites one; `delete <id>` removes one. `models` lists the generation models for prompt-driven assets with each one's price and whether this key can use it; `models <id>` prints the options a model accepts. `generate <model> "<prompt>"` generates one asset on its own and prints its URL.
+Commands for the Shotstack video rendering API. `render` submits an Edit JSON and returns a render ID; `status` polls a render until done. `ingest` uploads your own local files (or fetches remote URLs) and hosts them so they can be referenced from an Edit. `validate` lints an Edit — run it before every render. `studio` opens an edit in the browser editor for a human to preview, tweak, and render. `template list|get|create|update|delete` reads and writes templates saved to the account: `list` shows saved templates (id + name); `get <id>` fetches a saved template's Edit JSON (e.g. one the user designed in Studio) so you can render or remix it; `create <file> --name <name>` saves an edit as a new template; `update <id> <file>` overwrites one; `delete <id>` removes one. `models` lists the generation models for prompt-driven assets and whether this key can use each one; `models <id>` prints the options a model accepts. `generate <model> "<prompt>"` generates one asset on its own and prints its URL.
 
 **Default loop — no API key required:** compose → `validate` (offline lint) → `studio` (browser preview). Only the API-backed commands (`render`, `status`, `ingest`, `models`, `generate`) need a key. Reach for `render` when you specifically need a final MP4 exported in the cloud; reach for `studio` for everything else — it is the cheapest way to see an edit and the right default for any creative a human will review.
 
@@ -96,7 +96,7 @@ Other ingest subcommands: `ingest fetch <url>` (host a copy of a remote URL), `i
 
 ## Generating assets
 
-An `image`, `video` or `audio` asset with a `prompt` and a `model` is generated by AI. `shotstack models` lists the models, whether this API key can use each one, and its price in credits. `shotstack models <id>` adds the JSON Schema for that model's `options`. Read it before setting `options`, because values outside it are rejected.
+An `image`, `video` or `audio` asset with a `prompt` and a `model` is generated by AI. `shotstack models` lists the models and whether this API key can use each one. `shotstack models <id>` adds the JSON Schema for that model's `options`. Read it before setting `options`, because values outside it are rejected.
 
 ```sh
 shotstack models --output json
@@ -115,7 +115,7 @@ shotstack generate seedance-2.0-text-to-video "Waves break over black sand at du
 
 `--length` is the clip length in seconds. Models that generate to a duration use it in place of their own duration option.
 
-**Generation costs credits on stage as well as v1.** Before generating, tell the user the model and its price from `shotstack models <id>`, and wait for a yes. Identical requests share one job and its cached result: repeating a request while it runs, or after it finishes, returns the same job without charging again. That is also how to pick up a job started without `--watch`. Sending a failed generation again retries it, and that is charged.
+**Generation costs credits on stage as well as v1.** Before generating, run the same command with `--quote`, tell the user the model and the credits it prints (it says "up to" when the final charge can be lower), and wait for a yes. Identical requests share one job and its cached result: repeating a request while it runs, or after it finishes, returns the same job without charging again. That is also how to pick up a job started without `--watch`. Sending a failed generation again retries it, and that is charged.
 
 **Read [`references/generation.md`](references/generation.md) before writing a prompt.** It covers what each model responds to, when to put text in a `rich-text` layer instead of the image, and how to size and chain generations inside an edit.
 
 
@@ -252,7 +252,7 @@ Set `prompt` and `model` on an `image`, `video` or `audio` asset and it is gener
 { "asset": { "type": "video", "prompt": "Slow dolly across a rain-soaked neon street at night", "model": "seedance-2.0-text-to-video", "options": { "resolution": "720p" } }, "start": 0, "length": 5 }
 ```
 
-The models endpoint (`GET /models`) lists each model, whether the account can use it, its price, and the JSON Schema for its `options`. Options outside that schema are rejected. To animate a still, use an image-to-video model and put the image URL in `options.startSrc` (`inputSrc` on the original image-to-video models).
+The models endpoint (`GET /models`) lists each model, whether the account can use it, and the JSON Schema for its `options`. `POST /generate/quote` takes the same body as `POST /generate` and returns its cost in credits without charging. Options outside that schema are rejected. To animate a still, use an image-to-video model and put the image URL in `options.startSrc` (`inputSrc` on the original image-to-video models).
 
 Generation is billed per asset **even on the stage endpoint**, which is otherwise free. Renders containing AI assets take longer, because the render waits for each generation.
 
 
@@ -8,6 +8,7 @@ import { withRecording, commandArgv, type CommandResult } from "../recorder.ts";
 import { fetchModel, formatAvailability, type GenerationModel } from "./models.ts";
 
 export type Generation = components["schemas"]["GenerationResponse"];
+export type GenerationQuote = components["schemas"]["GenerationQuote"];
 
 export interface GenerateInput {
   model: string;
@@ -26,20 +27,29 @@ export const generateCommand = new Command("generate")
   .option("--options <json>", "Model options as a JSON object (see `shotstack models <model>`)", parseOptionsJson)
   .option("--length <seconds>", "Length of the clip the asset fills; models that generate to a duration use it", parseSeconds)
   .option("--watch", "Poll until the asset is ready, then print its URL")
+  .option("--quote", "Print the credits this exact request would cost, without generating or charging")
   .option(`--env <name>`, `Environment: ${ENV_NAMES.join(" | ")}`)
   .option("--output <format>", "Output format: text | json", "text")
   .action(
     async (
       model: string,
       prompt: string,
-      options: { options?: Record<string, unknown>; length?: number; watch?: boolean; env?: string; output: string },
+      options: {
+        options?: Record<string, unknown>;
+        length?: number;
+        watch?: boolean;
+        quote?: boolean;
+        env?: string;
+        output: string;
+      },
     ) => {
       await withRecording("generate", commandArgv("generate"), async () => {
         const format = parseOutputFormat(options.output);
         const env = resolveEnv(options.env);
         const apiKey = requireApiKey(env.name);
         const client = createClient({ apiKey, env });
         const input = { model, prompt, options: options.options, length: options.length };
+        if (options.quote) return runQuote(client, input, format);
         return runGenerate(client, input, format, options.watch === true);
       });
     },
@@ -75,6 +85,19 @@ export async function runGenerate(
   return { renderId: final.id, response: final, exitCode: final.status === "failed" ? 1 : 0 };
 }
 
+// The API refuses a quote for a model the key can't use, so there's no availability check here.
+export async function runQuote(client: Client, input: GenerateInput, format: OutputFormat): Promise<CommandResult> {
+  const model = await fetchModel(client, input.model);
+  const quote = await client.post<GenerationQuote>("/generate/quote", buildRequest(model, input));
+  emit(format, quote, formatQuote(quote));
+  return { response: quote };
+}
+
+// `ceiling` means the duration isn't known yet, so the charge can come in lower.
+export function formatQuote(q: GenerationQuote): string {
+  return `${q.ceiling ? "up to " : ""}${q.credits} ${q.credits === 1 ? "credit" : "credits"}`;
+}
+
 export function buildRequest(model: GenerationModel, input: GenerateInput) {
   return {
     asset: {
 
@@ -6,17 +6,9 @@ import { resolveEnv, ENV_NAMES } from "../http/env.ts";
 import { emit, parseOutputFormat } from "../output.ts";
 import { withRecording, commandArgv } from "../recorder.ts";
 
-// The published schema has no `pricing`; API deployments that predate generation quotes still send it.
-type GenerationModelPricing = {
-  credits: number | Record<string, number>;
-  tieredBy?: { option: string; default: string };
-  quantity?: { measure: string; per: number };
-};
-export type GenerationModel = components["schemas"]["GenerationModel"] & { pricing?: GenerationModelPricing };
+export type GenerationModel = components["schemas"]["GenerationModel"];
 type GenerationModelList = components["schemas"]["GenerationModelListResponse"];
 
-const UNIT_NOUNS: Record<string, string> = { clipSeconds: "second", promptCharacters: "character" };
-
 export async function listModels(client: Client): Promise<GenerationModel[]> {
   const result = await client.get<GenerationModelList>("/models");
   return result.models;
@@ -28,7 +20,7 @@ export async function fetchModel(client: Client, id: string): Promise<Generation
 }
 
 export const modelsCommand = new Command("models")
-  .description("List generation models with availability and price, or show one model's options")
+  .description("List generation models with availability, or show one model's options")
   .argument("[id]", "Model id; prints the JSON Schema for its options")
   .option(`--env <name>`, `Environment: ${ENV_NAMES.join(" | ")}`)
   .option("--output <format>", "Output format: text | json", "text")
@@ -58,32 +50,15 @@ export function formatAvailability(model: GenerationModel): string {
   return "availability unknown";
 }
 
-export function formatPrice(pricing: GenerationModelPricing): string {
-  const unit = formatUnit(pricing.quantity);
-  if (typeof pricing.credits === "number") return `${pricing.credits} ${pricing.credits === 1 ? "credit" : "credits"} ${unit}`;
-  const fallback = pricing.tieredBy?.default;
-  const tiers = Object.entries(pricing.credits)
-    .map(([tier, credits]) => `${tier} ${credits}${tier === fallback ? " (default)" : ""}`)
-    .join(", ");
-  return `credits ${unit} by ${pricing.tieredBy?.option ?? "option"}: ${tiers}`;
-}
-
-function formatUnit(quantity: GenerationModelPricing["quantity"]): string {
-  if (!quantity) return "per generation";
-  const noun = UNIT_NOUNS[quantity.measure] ?? quantity.measure;
-  return quantity.per === 1 ? `per ${noun}` : `per ${quantity.per} ${noun}s`;
-}
-
 function formatModelTable(models: GenerationModel[]): string {
-  const rows = models.map((m) => [m.model, m.type, formatAvailability(m), m.pricing ? formatPrice(m.pricing) : ""]);
+  const rows = models.map((m) => [m.model, m.type, formatAvailability(m)]);
   const widths = rows[0]!.map((_, col) => Math.max(...rows.map((row) => row[col]!.length)));
   return rows.map((row) => row.map((cell, col) => cell.padEnd(widths[col]!)).join("  ").trimEnd()).join("\n");
 }
 
 function formatModelDetail(model: GenerationModel): string {
   const lines = [`${model.model}  ${model.type}  ${formatAvailability(model)}`];
   if (model.name) lines.push(model.description ? `${model.name}: ${model.description}` : model.name);
-  if (model.pricing) lines.push(`Price: ${formatPrice(model.pricing)}`);
   if (model.options) lines.push("Options:", JSON.stringify(model.options, null, 2));
   return lines.join("\n");
 }
@@ -1,6 +1,14 @@
 import { describe, test, expect, mock } from "bun:test";
 import { InvalidArgumentError } from "commander";
-import { buildRequest, parseOptionsJson, parseSeconds, runGenerate, type Generation } from "../src/commands/generate.ts";
+import {
+  buildRequest,
+  formatQuote,
+  parseOptionsJson,
+  parseSeconds,
+  runGenerate,
+  runQuote,
+  type Generation,
+} from "../src/commands/generate.ts";
 import type { GenerationModel } from "../src/commands/models.ts";
 import type { Client } from "../src/http/client.ts";
 
@@ -68,3 +76,21 @@ describe("runGenerate", () => {
     expect(result.exitCode).toBe(1);
   });
 });
+
+describe("runQuote", () => {
+  test("quotes the exact request generate would send, without generating", async () => {
+    const post = mock(async () => ({ credits: 0.6038, ceiling: false }));
+    const get = mock(async () => video);
+    const client = { get, post } as unknown as Client;
+    const input = { model: video.model, prompt: "waves", length: 5 };
+    const result = await runQuote(client, input, "json");
+    expect(post).toHaveBeenCalledTimes(1);
+    expect(post).toHaveBeenCalledWith("/generate/quote", buildRequest(video, input));
+    expect(result.response).toEqual({ credits: 0.6038, ceiling: false });
+  });
+
+  test("says 'up to' when the quote is a ceiling", () => {
+    expect(formatQuote({ credits: 2.5, ceiling: true })).toBe("up to 2.5 credits");
+    expect(formatQuote({ credits: 1, ceiling: false })).toBe("1 credit");
+  });
+});
@@ -1,5 +1,5 @@
 import { describe, test, expect } from "bun:test";
-import { fetchModel, formatAvailability, formatPrice, type GenerationModel } from "../src/commands/models.ts";
+import { fetchModel, formatAvailability, type GenerationModel } from "../src/commands/models.ts";
 import type { Client } from "../src/http/client.ts";
 
 const model = (fields: Partial<GenerationModel>): GenerationModel => ({ model: "m", type: "image", ...fields });
@@ -31,26 +31,3 @@ describe("formatAvailability", () => {
     expect(formatAvailability(model({ available: true }))).toBe("available");
   });
 });
-
-describe("formatPrice", () => {
-  test("flat rate per generation", () => {
-    expect(formatPrice({ credits: 0.1, effectiveFrom: "legacy" })).toBe("0.1 credits per generation");
-  });
-
-  test("rate per counted unit", () => {
-    expect(
-      formatPrice({ credits: 1, quantity: { measure: "promptCharacters", per: 1000 }, effectiveFrom: "legacy" }),
-    ).toBe("1 credit per 1000 characters");
-  });
-
-  test("tiered rate names the option and marks its default", () => {
-    expect(
-      formatPrice({
-        credits: { "480p": 0.9375, "720p": 1.8962 },
-        tieredBy: { option: "resolution", default: "720p" },
-        quantity: { measure: "clipSeconds", per: 1 },
-        effectiveFrom: "2026-08-13",
-      }),
-    ).toBe("credits per second by resolution: 480p 0.9375, 720p 1.8962 (default)");
-  });
-});