GPT-6.2 Astra for Video Scripts: API Pricing and a Real Pipeline Test

GPT-6.2 Astra is the flagship of OpenAI's GPT-6.2 series, listed at $8 and $40 per million tokens with a context window of about a million tokens. On our script probe it wrote a 30-second Short's script for about six tenths of a cent in 5.2 seconds. Here is the rate card, the same prompt on GPT-6.2 Sol, Astra Pro and Claude Sonnet 5, what pro mode really costs, and how it fits a pipeline that writes, narrates, renders and publishes.

Alex Daro
Alex Daro
GPT-6.2 Astra for Video Scripts: API Pricing and a Real Pipeline Test

GPT-6.2 Astra is the top model in OpenAI's GPT-6.2 series. It reached OpenRouter on 17 November 2026 and joined the model picker on Treza's Text Generation node the next day, together with three siblings: GPT-6.2 Astra Pro, GPT-6.2 Sol and GPT-6.2 Sol Pro. It takes images as input, carries a context window of about 1.05 million tokens, and lists at $8 per million input tokens and $40 per million output tokens, below the $10 and $50 that GPT-6 Astra listed at.

In a video pipeline, a language model's main job is the script that every later node narrates, renders and cuts, so that is the job we tested it on. Every price below is the listed rate as of November 2026, and every test number is what the provider billed and what the clock said.

The rate card

GPT-6.2 AstraGPT-6.2 SolClaude Sonnet 5
Input, per million tokens$8.00$2.00$2.00
Output, per million tokens$40.00$10.00$10.00
Context window1,050,000 tokens1,050,000 tokens200,000 tokens
Image inputYesYesYes
WeightsHosted onlyHosted onlyHosted only

Astra costs four times Sol and four times Sonnet 5 per token. The Pro variants list at the same rates as their base models (Astra Pro at $8 and $40, Sol Pro at $2 and $10), but as the test below shows, the same rate does not mean the same bill. Our Astra probe was billed exactly at the list rate, so there is no hidden request fee.

The test: one prompt, four models

Every language model that joins the Text Generation node gets the same probe before it is listed: the node's own request with the node's defaults (temperature 0.7, a 1,024 token cap, reasoning off), the system prompt "You write short-form video scripts", and this user prompt:

Write a 30-second vertical video script about why octopuses have three hearts. Use exactly these sections: HOOK (one line), BEATS (4 numbered lines, each under 15 words), ON-SCREEN TEXT (4 captions, each under 6 words), CTA (one line). No emojis, no markdown headers.

We ran it on GPT-6.2 Astra, Astra Pro and Sol on 18 November, and on Claude Sonnet 5, the node's default model, the same day.

GPT-6.2 AstraGPT-6.2 Astra ProGPT-6.2 SolClaude Sonnet 5
Prompt tokens842,10684122
Reply tokens140339130212
Billed by the provider$0.0063$0.0304$0.0015$0.0024
Wall time5.2 s8.5 s3.3 s4.8 s
FinishStopped on its own, all four sectionsStopped on its own, all four sectionsStopped on its own, all four sectionsStopped on its own, all four sections

Astra wrote a shorter reply than Sonnet 5, 140 tokens against 212, and still cost about 2.6 times as much per script, because each of those tokens costs four times as much. It was about half a second slower. Sol wrote a reply of nearly the same length as Astra's for about a quarter of the price, in 3.3 seconds, the fastest of the four.

What pro mode adds

Look at Astra Pro's prompt tokens. We sent the same 84 token request, and the provider counted 2,106. Pro mode adds about 2,000 tokens of its own instructions to every call, billed as input, and it reasoned even with reasoning switched off: 57 of its 339 reply tokens were reasoning. The result was a script that cost almost five times what Astra's did and took more than three seconds longer.

Sol Pro showed the same pattern: 2,291 prompt tokens, 266 reasoning tokens with reasoning off, $0.0102 and 11.1 seconds for one script. So on a short job like this one, the Pro variants are the expensive way to buy the same model. The extra tokens are a fixed cost per call, which matters less when the prompt is already long and the task is hard, and matters a lot on a 30 second script.

What GPT-6.2 Astra wrote

The reply, unedited:

HOOK One octopus, three hearts. Why does one body need three pumps?

BEATS

  1. Picture an octopus's two gills, each with its own heart.
  2. Each heart pumps blood through one gill, where it picks up oxygen.
  3. Blood from both gills flows to the third heart, the main pump.
  4. That heart sends oxygen-rich blood everywhere, right to the tips of all eight arms.

ON-SCREEN TEXT Two gills, two hearts Blood picks up oxygen Next stop: heart three Oxygen for eight arms

CTA Quiz a friend: can they name the two jobs those three hearts do?

The format held. Four beats, the longest fourteen words against a limit of fifteen. Four captions, none over four words against a limit of six. No emojis, no headers, and each label on its own line, the shape a downstream node splitting on the labels expects.

The writing follows the blood, gill to main pump to arms, so each beat is one shot and each caption names what that shot shows.

The fact Sonnet 5 still gets wrong

When we tested Kimi K3.1 Pro in October, three models put the same error in their hooks: that two of the octopus's hearts stop when it swims. The standard account is the reverse. The two branchial hearts keep pushing blood through the gills, and the single systemic heart, the one that serves the body, stops during swimming, which is why octopuses prefer to crawl.

On 18 November Sonnet 5 made that mistake again, in its hook and in its third beat. Astra did not, but only because it left swimming out: every fact it stated is right, and it never reached for the surprising one. Sol did the same. Sol Pro was the only one of the four that used the swimming fact, and it got it right.

So the newest flagship did not fix this problem; it avoided it. The pipeline fix stays cheap: a second Text Generation node after the writer, on a cheaper model, that checks the hook against the beats and answers with a corrected hook before text to speech. The faceless script guide covers the system prompt rules that keep scripts on the rails in the first place.

The same model on an image

The Text Generation node takes a Media input, so the second probe wired in a product photo of a folded navy shirt on a wood table. Astra described it in 6.5 seconds for $0.0036, naming the shirt, the pointed collar, the fabric weave, the pale wood, the warm light and the shallow depth of field. That is the shape of a judge that checks a generated frame against its brief. Sol named the same details.

Where Astra fits, and when Sol is enough

A script on GPT-6.2 Astra cost $0.0063. On Sol it cost $0.0015, and on Sonnet 5 $0.0024. A channel writing one script a day for a year spends about $2.29 on Astra, $0.54 on Sol and $0.86 on Sonnet 5. Next to the price of rendering and narrating the video itself, which the AI video cost breakdown walks through, all three are small.

So the per-script price does not decide it, and on our probe the quality did not either: Astra and Sol wrote scripts of the same structure, accuracy and length. For a short, well specified script, Sol is enough, and it was faster. Astra is the one to try where the writing is harder: a long brief with many constraints, a script built from a full transcript, or a rewrite that has to keep a specific voice. Both carry the same 1.05 million token window, so context is not the difference. Sonnet 5 stays the node's default because it carries the production record on Treza, and the Pro variants are the ones to skip for scripts.

Running GPT-6.2 Astra as the script step

On a Treza AI video pipeline, the script is the first node in the chain. Set the Text Generation node's model to GPT-6.2 Astra, put the channel's angle and voice in its system prompt, and turn on Avoid recent repeats so a scheduled channel does not rewrite last week's video; the node remembers up to 50 previous runs. Set a fallback model, Sol is a natural one, so a call that fails after retries moves on rather than failing the run.

From there the script feeds the rest of the line. A text to speech node reads it in a built-in voice, the setup the AI voiceover generator page walks through. Each scene renders as its own clip on the video model you pick, the Sequence node stitches the shots against the narration, captions are burned in, and a YouTube or TikTok node publishes it. The faceless video generator page covers that build, and the script to video page covers the case where the script already exists and the model's job is to split it into scenes.

Publish the pipeline and it becomes a versioned endpoint with a typed /invoke route and an OpenAI-compatible route, and our hosted MCP server exposes it as a tool an agent can call. When a better writer arrives, you change the dropdown and republish, and the endpoint does not change. The node's language models sit alongside the video and image models in the model library.

What you actually pay on Treza

A Text Generation node is metered from a prepaid credit balance. One credit equals $0.01, packs start at $5, credits never expire, and a failed generation charges nothing. A text node settles at what the provider billed. To try the model on your own brief, open the AI video generator, set the script node to GPT-6.2 Astra, and run one.

Frequently Asked Questions

How much does GPT-6.2 Astra cost per million tokens?

$8.00 per million input tokens and $40.00 per million output tokens, as of November 2026, with no per-request fee. That is four times GPT-6.2 Sol and Claude Sonnet 5, and below the $10 and $50 that GPT-6 Astra listed at. Our probe was billed exactly at the list rate.

How much does a video script cost on GPT-6.2 Astra?

Our 30-second Short script, an 84 token prompt into a 140 token reply, was billed $0.0063 and took 5.2 seconds. The same prompt cost $0.0015 on GPT-6.2 Sol, $0.0024 on Claude Sonnet 5 and $0.0304 on GPT-6.2 Astra Pro. On Treza the charge comes from a prepaid credit balance, and a failed call charges nothing.

What is the difference between GPT-6.2 Astra and Astra Pro?

They list at the same rates, but Astra Pro adds about 2,000 tokens of its own to every prompt and reasoned even with reasoning off. On our script probe that made it almost five times as expensive as Astra, $0.0304 against $0.0063, and 3.3 seconds slower, for a script of the same structure.

Is GPT-6.2 Astra better than GPT-6.2 Sol for video scripts?

Not on a short, well specified script. On our probe both held every rule in the prompt, stated only correct facts and wrote replies of nearly the same length, and Sol did it for about a quarter of the price in 3.3 seconds against 5.2. Astra is worth its price on harder writing: long briefs, many constraints, or a script built from a long transcript.

How do I use GPT-6.2 Astra in a video pipeline through an API?

On a Treza pipeline, GPT-6.2 Astra is a choice in the Text Generation node's model picker. Wire that node to text to speech, video generation, captions and publishing, publish the pipeline, and call it as a versioned HTTP endpoint. Generations are metered from prepaid credits that start at $5 and never expire.