DEV Community: Owen

Use DeepSeek V4.1 Flash in Claude Code: setup guide

Owen — Sun, 13 Sep 2026 11:34:07 +0000

Claude Code can connect to DeepSeek V4.1 Flash through https://api.deepseek.com/anthropic. DeepSeek’s documented setup uses deepseek-flash[1m] for the main, Opus and Sonnet selections, and deepseek-flash for Haiku and subagents. Those distinctions appear in the official Claude Code integration guide.

This guide was checked on September 10, 2026, against the direct DeepSeek documentation. We have not run paid inference or verified a successful Claude Code task. The release overview and API setup guide explain the model and its direct API access.

Configure an existing Claude Code installation

First check that claude --version works. If Claude Code is absent, install it using the current Claude Code installation instructions before applying provider settings. Obtain a DeepSeek API key from the DeepSeek Platform.

For macOS or Linux, use these settings in the terminal from which you will launch Claude Code. Replace the token placeholder locally. Quoting the model names keeps the [1m] suffix from being interpreted as a shell filename pattern:

export ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="REPLACE_WITH_DEEPSEEK_API_KEY"
export ANTHROPIC_MODEL="deepseek-flash[1m]"
export ANTHROPIC_DEFAULT_OPUS_MODEL="deepseek-flash[1m]"
export ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-flash[1m]"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-flash"
export CLAUDE_CODE_SUBAGENT_MODEL="deepseek-flash"
export CLAUDE_CODE_EFFORT_LEVEL="max"
export CLAUDE_CODE_AUTO_COMPACT_WINDOW="786432"

These are the values in DeepSeek’s published integration, including the effort and compaction settings. The [1m] form is a client integration setting; the direct API model name remains deepseek-flash. Do not append the suffix to every API request by assumption.

Windows users can use the equivalent $env:NAME="value" assignments listed in the official guide. Keep credentials out of project files and shared terminal transcripts. Start with session-level settings so your existing provider setup remains easy to restore.

Check every model selection, not just the main one

The Opus, Sonnet, Haiku and subagent variables matter because a workflow can select more than its main model. Keeping an old default can leave some requests on a different route.

DeepSeek also documents automatic mappings for incoming Claude model names: claude-opus names map to V4 Pro, while claude-haiku and claude-sonnet names map to Flash. Its guide says the Opus mapping retains Pro billing until September 14, 2026, at 12:00 Beijing time (UTC+8). After that, Pro requests move to Flash and Flash billing. See the Pro migration guide for the scheduled change.

That is why the explicit Flash settings above are preferable when your goal is to evaluate V4.1 Flash now. A familiar Claude label does not prove which DeepSeek model or rate served the request.

Validate a small workflow and its cost

Enter a test project and run claude from the configured terminal. Ask it to explain one file before requesting a bounded edit. Check the resulting diff, tool behavior and test outcome; if your normal workflow delegates work, verify that path too.

Inspect the provider’s usage and billing records for the task. Our example is a setup procedure, not evidence of tested speed, savings or equivalent coding quality. The Flash pricing guide separates input cache hits, misses, output and peak/off-peak pricing.

If authentication fails, check the key and endpoint together. A request-format problem needs the response’s error details; repeatedly changing model names will not repair an incorrect protocol. Codex uses a different setup through the Responses API.

For a gateway such as Ofox, verify its actual model ID, Anthropic support and account price before replacing these direct-provider settings. The Ofox catalog is a place to begin that check; this article does not confirm that V4.1 Flash is available through Ofox or that signing up enables it.

Frequently Asked Questions

What model name should I set in Claude Code for DeepSeek V4.1 Flash?

DeepSeek's official integration sets ANTHROPIC_MODEL, ANTHROPIC_DEFAULT_OPUS_MODEL and ANTHROPIC_DEFAULT_SONNET_MODEL to deepseek-flash[1m]. It uses deepseek-flash without the suffix for Haiku and subagents.

Which base URL does the direct DeepSeek integration use?

Set ANTHROPIC_BASE_URL to https://api.deepseek.com/anthropic and authenticate with a DeepSeek API key in ANTHROPIC_AUTH_TOKEN. Do not substitute the Codex Responses configuration.

Does selecting a Claude Opus alias guarantee Flash billing?

No. DeepSeek documents claude-opus names as mapping to V4 Pro, with Pro billing until September 14, 2026, at 12:00 Beijing time. Use the explicit Flash settings and check provider usage records.

Originally published on ofox.ai/blog.

DeepSeek V4.1 Flash API: pricing, providers and setup

Owen — Sun, 13 Sep 2026 04:32:30 +0000

To call DeepSeek V4.1 Flash directly, use deepseek-flash at https://api.deepseek.com. Before buying credit, choose the provider and protocol, estimate the task cost, then configure a key issued by that same provider. This guide follows that full path, from a purchase decision to the first request.

Checked against DeepSeek's official documentation on September 11, 2026. The code is documentation-checked and syntax-checked; it is not a paid end-to-end test. Running the examples can consume credit.

1. Choose where to obtain API access

The official release log confirms direct API access. A third-party entry needs its own verification: DeepSeek's legacy-name routing does not establish a gateway's model mapping.

Destination	What this check establishes	What to confirm before funding
Direct DeepSeek API	Official documentation identifies `deepseek-flash` as V4.1 Flash	Your account access, current rates and required operation
Ofox	The retrieved public catalog showed older DeepSeek entries; this check did not establish a V4.1 serving route	Actual model version and ID, protocol, account price and payment terms
Another gateway	Not certified by this guide	Its own current catalog, protocol documentation and billing terms

The Ofox result is a limit of verification, not proof of unavailability. A provider may update routing independently of display labels; a blog announcement alone does not prove a purchasable route exists. Confirm the operation you need: text chat, Codex Responses, Claude Code tools and image input are separate compatibility checks.

For Ofox, inspect the catalog and authentication documentation. If a confirmed route meets your requirements, create an account and prepare an API key. A gateway account does not fund your direct DeepSeek account.

2. Calculate the cost before buying credit

These are direct DeepSeek USD prices per one million tokens, checked on the official pricing page. They are not an Ofox quote.

Token category	Off-peak USD / 1M tokens	Peak USD / 1M tokens
Input with a cache hit	$0.003	$0.006
Input with a cache miss	$0.15	$0.30
Output	$0.60	$1.20

Peak periods are Monday–Friday, 01:00–04:00 and 06:00–10:00 UTC. Other times are off-peak. These periods are 09:00–12:00 and 14:00–18:00 in Beijing, or 10:00–13:00 and 15:00–19:00 in Tokyo and Seoul. Use timezone-aware conversion where clocks change seasonally. For a request crossing a price boundary, check the actual billing rule instead of inventing a split-charge formula.

A repeated prompt does not prove the whole input was billed as cached. Check the returned usage and billing record. For mixed input, estimate:

Cost = cached_input_tokens / 1_000_000 × cached_input_rate
     + uncached_input_tokens / 1_000_000 × uncached_input_rate
     + billed_output_tokens / 1_000_000 × output_rate

For example, 100 requests with 10,000 uncached input tokens and 2,000 billed output tokens each total 1 million input and 0.2 million output tokens:

Off-peak: (1 × $0.15) + (0.2 × $0.60) = $0.27
Peak:     (1 × $0.30) + (0.2 × $1.20) = $0.54

That budget fits 18 complete 100-request batches into $5 outside peak hours, or 9 at peak rates, excluding provider-specific fees. It does not guarantee 1,800 useful tasks: agents can make multiple calls, retry, accumulate history and consume more output than a final visible answer suggests.

When comparing sellers, replace the official rates with the destination's quote. Check its minimum payment, purchase fees, time bands and refund conditions. Budget one complete representative task before increasing the balance.

3. Match the account, key and model

Obtain a key from the provider you will call. A direct key from the DeepSeek Platform belongs with the DeepSeek endpoint; an Ofox key belongs with the documented Ofox route. Store the direct credential locally as DEEPSEEK_API_KEY; do not commit or print it.

Use the exact model ID. The official deepseek-flash name now selects V4.1 Flash. Older Flash names are compatibility aliases, while an expires-on-0910 beta configuration belongs to an earlier rollout stage. Existing Pro users should also read the migration guidance.

4. Make one small Python or curl request

Following the official quickstart, install the compatible Python client in your project environment with python -m pip install openai, then use:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)
response = client.chat.completions.create(
    model="deepseek-flash",
    messages=[{"role": "user", "content": "Reply with one short greeting."}],
    max_tokens=128,
    extra_body={"thinking": {"type": "disabled"}},
)
print(response.choices[0].message.content)
print(response.usage)

This starts without thinking or tools so the diagnostic task is small. After the basic call works, add required capabilities one at a time and check their documented parameters.

The equivalent curl request is:

curl --fail-with-body https://api.deepseek.com/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{"model":"deepseek-flash","messages":[{"role":"user","content":"Reply with one short greeting."}],"max_tokens":128,"thinking":{"type":"disabled"}}'

Keep a sanitized error body if the call fails. Do not share a verbose trace containing the authorization header. For JavaScript, the OpenAI SDK option is baseURL; the model and JSON fields stay the same. Follow your installed SDK's interface rather than mechanically copying Python argument names.

5. Configure the protocol your client needs

Client or operation	What to check next
Chat Completions	`/chat/completions` with `messages`
Codex	Responses provider settings and the complete model catalog
Claude Code	Anthropic-compatible base path, main-model aliases and subagents
Image understanding	Supported image content blocks and the chosen route's visual input support

Use the dedicated Codex guide or Claude Code guide for client configuration. A text reply alone does not validate a tool loop, image input or streaming parser. Main-model selection also does not establish which model every helper uses.

6. Diagnose the error before adding credit

If a model is missing, check the destination and exact identifier first. A stale client catalog may not list deepseek-flash, and a gateway may use a different ID. Do not assume all providers return the same unknown-model error.

The official error reference distinguishes 401 authentication, 402 insufficient balance, 400 request format, 422 parameters and 429 rate limits. Adding credit addresses an identified balance problem; it does not fix the other categories. Limit retries and pace transient failures deliberately.

After a successful representative task, record the model, provider, time, token usage and billed amount without secrets. Compare the bill with your budget and check the result's usefulness. Increase funding only after the needed operation and its cost have been verified on the actual route.

Frequently Asked Questions

What model ID calls DeepSeek V4.1 Flash?

Use deepseek-flash on the direct DeepSeek API. A gateway can use its own identifier; verify the route before using or funding it.

How much does the official V4.1 Flash API cost?

The September 10 direct API rates per million tokens outside peak hours are $0.003 for cached input, $0.15 for uncached input and $0.60 for output. Peak prices are twice those rates. Gateway prices must be checked separately.

Where can I buy access?

The official DeepSeek API is documented as available. For a gateway, confirm its actual model version, supported protocol, account price and payment terms before funding it. This check has not established an Ofox V4.1 route.

Can I use a DeepSeek key on Ofox?

Use the credential issued by the provider receiving the request. Provider keys and balances are separate; do not combine a DeepSeek key with an Ofox endpoint.

Will adding credit fix an API error?

It can address a confirmed insufficient-balance error, such as 402 on the direct API. It does not fix authentication, malformed requests, an unsupported model or client configuration.

Originally published on ofox.ai/blog.

Codex GPT-5.5 model not found: diagnose the 404

Owen — Sat, 12 Sep 2026 11:34:10 +0000

If Codex reports that gpt-5.5 does not exist or you do not have access to it, check the combination of model ID, provider and authentication before changing your subscription. A valid ChatGPT login does not establish access through an API key, and a valid provider key does not establish that the provider accepts the model ID in your configuration.

This guide is for a Codex CLI session showing an error such as:

unexpected status 404 Not Found: The model `gpt-5.5` does not exist or you do not have access to it.

The wording identifies the requested model, not the cause. It is not evidence that GPT-5.5 was retired. The steps below are based on the official Codex configuration and authentication documentation checked on September 8, 2026; they do not claim that GPT-5.5 is available to every account or provider.

Start with the route, not a reinstall

Run these inspection commands in the same terminal where Codex fails:

codex --version
codex login status
codex --help

Record the version and authentication method. Also record the directory you launched from, any --model, --profile or -c arguments, and whether an IDE launched the session. Do not share API keys, access tokens or the contents of auth.json.

codex login status describes authentication; it is not a complete report of the endpoint selected by a custom provider. Read it alongside the provider configuration.

Your intended connection	What to check first	What not to infer
ChatGPT sign-in	Correct account/workspace and a model offered for that session	A ChatGPT subscription guarantees the same model through the API
OpenAI API key	Intended API account/project, model availability and OpenAI endpoint	A successful ChatGPT session proves this API key has access
Third-party provider	Provider URL, its model ID and the environment variable supplying its key	An OpenAI model ID or OpenAI key automatically works on that provider

OpenAI documents the distinction between ChatGPT subscription access and API-key usage-based access. Keep those routes separate throughout the diagnosis.

Find the setting Codex actually reads

A common troubleshooting mistake is editing the user configuration while the launch command still selects another model. Inspect the relevant configuration files locally and record only the fields you need:

model
model_provider
openai_base_url
model_providers.<provider>.base_url
model_providers.<provider>.env_key
model_providers.<provider>.requires_openai_auth

According to the current configuration basics, precedence runs from highest to lowest:

CLI flags and --config overrides.
Trusted project configuration, with the file closest to the working directory winning.
The profile file selected with --profile.
User configuration at ~/.codex/config.toml.
System configuration, then built-in defaults.

There is an important restriction: current advanced configuration documentation says project configuration ignores provider-related keys such as model_provider, model_providers and openai_base_url, with a startup warning. Keep provider definitions in user-level configuration. A project can still override other allowed settings, including the model, so inspecting only one file can miss a mismatch.

The current docs describe profile files as ~/.codex/profile-name.config.toml. Older tutorials may use a different profile layout. Check your installed version before copying either format.

Repair the connection you intended to use

If you intended ChatGPT sign-in

Confirm the account and workspace, then select a model actually available in that session. Remove an obsolete model override from the launch command or the configuration layer that supplied it. If the model is not offered, check account availability rather than assuming that manually entering gpt-5.5 grants access.

Only reauthenticate when the active account is wrong or authentication has failed. Reinstalling Codex or deleting credentials is not a necessary first step for a model lookup error.

If you intended an OpenAI API key

Confirm that the request uses the intended OpenAI endpoint and API account/project. Compare the requested ID with that account's current model availability. Check openai_base_url for an old proxy override before concluding that OpenAI rejected the request.

API access and billing are separate from included ChatGPT plan credits. If another model works with the same key, that is useful evidence about the route, but it does not prove access to GPT-5.5.

If you intended a third-party provider

Treat the URL, model identifier and key as one matched set. A provider may use a namespaced model ID; use its documented value rather than adding or removing a prefix by guesswork.

This is a configuration template, not a working endpoint or an assertion of GPT-5.5 availability. Replace both placeholders with values from your provider. Put these entries in user-level configuration, merging with existing sections rather than duplicating them:

model = "REPLACE_WITH_PROVIDER_MODEL_ID"
model_provider = "diagnostic_provider"

[model_providers.diagnostic_provider]
name = "My provider"
base_url = "https://api.example.com/v1"
env_key = "PROVIDER_API_KEY"
requires_openai_auth = false
wire_api = "responses"

The selected provider must support the Responses API; the current Codex configuration reference lists responses as the only supported wire_api value. A provider offering only Chat Completions cannot use this template. Set PROVIDER_API_KEY through your usual local secret-management method; do not paste the secret into a shared TOML file.

requires_openai_auth defaults to false; it is explicit here to keep this template on the provider-key route. If an existing provider definition sets it to true, Codex uses OpenAI authentication and ignores env_key. Check this setting when a provider key appears to have no effect.

Before editing, save a copy of the affected configuration. Keep unrelated settings. After editing, start a new session from the same directory and run a small request that does not ask Codex to edit files. API usage may be billed. Restore the saved configuration if the change breaks a previously working route.

For a broader setup walkthrough, see custom model providers in Codex. If you use Ofox, check the current model catalog for the exact ID and supported connection before configuring it.

Use the next response to narrow the cause

Result after the change	Next step
Same model-specific 404	Recheck effective model ID, host and account access; avoid repeated identical retries
HTML 404 or a generic route-not-found response	Check URL/path construction and proxy routing before blaming model permissions
401 authentication error	Check the credential for the selected provider; follow the Codex 401 guide
429 or a usage-limit message	Model lookup is no longer the only issue; inspect the actual quota/rate-limit response
A successful response	Confirm the intended account/provider and request record before resuming the larger job

If you compare a direct API request with Codex, use the same host, key, model and Responses endpoint. A successful Chat Completions request to another host does not isolate a Codex problem. A direct success on the matched route shifts attention toward Codex configuration or request differences; it does not prove which difference caused the error.

A local model metadata ... not found warning is also distinct from an HTTP 404. Capture the final server response rather than assuming those messages have the same cause. For non-Codex SDKs and Azure cases, use the general OpenAI model-not-found guide.

What to include if you still need support

Send a redacted report containing the Codex version, operating system, authentication type, selected model/provider, endpoint host and path, working-directory context, relevant startup warnings and the exact final error. Include the request ID if the provider supplies one. Exclude secrets and private prompts.

That report lets support distinguish account availability from a stale override or provider mismatch. It is a better next step than changing the account, model and endpoint all at once and losing the original evidence.

Sources

Frequently Asked Questions

Does a GPT-5.5 404 mean the model was removed?

No. The error alone does not distinguish an unavailable model from the wrong provider, model ID or account access. Check the request route and that account's current model availability.

Does a ChatGPT subscription pay for API requests?

Codex authentication with an API key uses API billing rather than included ChatGPT plan credits. Check which authentication route your session actually uses.

Should I delete auth.json to fix this?

Start with codex login status and your selected provider. Deleting credentials does not fix a wrong model ID or endpoint and can interrupt a working login.

Originally published on ofox.ai/blog.

Codex Errors: 15 Symptoms Mapped to a Tested Fix (2026)

Owen — Sat, 12 Sep 2026 04:34:14 +0000

TL;DR: Most Codex errors are misfiled. The message names the symptom, not the cause, so people spend an afternoon rotating an API key when the real problem is a Windows Store install path or a missing bubblewrap package. This page is the index: 15 failures we have reproduced, each mapped to the thing that is actually broken and to the page with the tested fix. Start with your version, then find your string.

Last updated 2026-08-31. Version numbers and issue states on this page were read from npm, GitHub and OpenAI’s own docs on that date.

For configuration rather than an error, go directly to config.toml paths and examples or custom providers and profiles. For an API model 404, use the model ID, access and endpoint checks. Match the actual error text before changing credentials or reinstalling.

What should you check before any Codex fix?

Three of the biggest error families in this list are regressions with a known fixed build. If you are on the broken build, the fix is the upgrade and nothing else on this page applies.

codex --version                    # CLI
npm view @openai/codex version     # latest published: 0.151.0

The editor extension carries its own version, and it is the one that matters for the “couldn’t load its resources” family: the break landed in 26.803.41515 and the fix landed in 26.810.41047. AGENTS.md loading in symlinked workspaces was fixed in CLI v0.138. Upgrade first, reproduce second.

Which Codex are you running?

Five surfaces ship under the same name and they fail in different places. Getting this wrong is the most common reason a fix does not work.

Surface	What it is	Where its errors come from
CLI	`@openai/codex`, a Rust binary with an npm wrapper	PATH, `~/.codex/config.toml`, the sandbox, auth
Editor extension	the Codex panel in VS Code and forks	resource loading, the app-server handshake, the native host
Chrome extension	browser control, installed from the ChatGPT desktop app	native host version, permissions, browser support
ChatGPT mobile	Codex inside the phone app	nothing local; it is a remote session
Desktop app	the ChatGPT desktop client that hosts the above	model picker, `model_catalog_json`

If your error mentions resources, a native host, or an app-server, you are in extension territory even if you also use the CLI. If it mentions config.toml, a sandbox, or a provider, you are in CLI territory.

Which Codex error do you have?

Every string below is quoted as it appears. Find yours, then follow the link for the reproduction and the fix.

Why will Codex not install or start?

Error message	What is actually wrong	Fix
`zsh: command not found: codex`	npm installed it somewhere not on your PATH, usually because of NVM, Volta, or a custom `npm prefix -g`	codex: command not found
`failed to start codex app-server (os error 3)`	Windows cannot resolve the path it was handed, most often a Microsoft Store install under `WindowsApps\`	failed to start codex app-server on Windows
`manifest entry is missing required path nodePath/resourcesPath`	the launcher read an install manifest whose recorded paths no longer exist	same page, fix 6
`unable to locate the codex cli binary`	the extension is looking for a CLI that was never installed, or was installed under a different user	failed to start codex app-server on Windows
`Codex could not start the extension. Codex couldn't load its resources.`	the `26.803.41515` regression, which breaks five different ways behind one message	couldn’t load its resources
`codex chrome native host is out of date`	the browser extension and the desktop app are on mismatched builds	couldn’t load its resources

Windows deserves its own note, because a lot of advice still says WSL2 is mandatory. It is not. The project README gives Windows its own one-liner:

Run the following on Windows to install Codex CLI: powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"

That installer needs no Node at all. WSL2 is a choice rather than a requirement, but the two paths get different sandboxes. Native versus WSL2 has the trade-off; the install guide has all the routes including the standalone installer that needs no Node at all.

Why can Codex not authenticate?

Error message	What is actually wrong	Fix
`Missing bearer or basic authentication in header`	no key was sent at all, usually an env var that never made it into the shell Codex runs in	Codex CLI 401: 9 tested causes
`Incorrect API key provided`	a key was sent and rejected, which is a different problem with a different fix	Codex CLI 401: 9 tested causes
requests hang and then time out on connect	a PAC or WPAD corporate proxy that Codex does not discover, or a missing CA certificate	Codex behind a corporate proxy

Nine failures return something a user reads as a 401, and only some of them are literally 401. Read the message body, not the status code.

Why has Codex run out of quota?

Error message	What is actually wrong	Fix
`You've hit your usage limit`	a subscription window closed; the reset is a server-side `resetsAt` timestamp, not a clock rule	Codex reset: when your limit clears
`429 Too Many Requests` on a metered key	rate limiting or a spend cap on the API side, which is a separate system from the subscription window	cap your spend with a drop-in API

This is the single biggest source of Codex searches we see, and most of the advice online is wrong about it. There is no fixed number of days to wait, there are exactly two windows, and an earned reset is a credit you can redeem rather than a date you wait for. A 429 on a metered key is not the same event at all: for what the code means per provider, see LLM API error codes.

Why does Codex refuse to run commands or read your files?

Error message	What is actually wrong	Fix
`command failed; retry without sandbox`	on Linux, `bubblewrap` is missing or cannot open the paths it needs; on any OS, `sandbox_mode` is stricter than the task	command failed; retry without sandbox
AGENTS.md is ignored, no error at all	the workspace path traverses a symlink, on CLI builds before v0.138	AGENTS.md not loading in symlinked workspaces

The sandbox one has a trap worth knowing: Codex prints a bubblewrap warning whose match string does not exist on every distribution, so a broken sandbox can fail silently on some Linux installs. The fix page has the five-distribution test.

Why will your model or provider not appear?

Error message	What is actually wrong	Fix
custom models missing from the Codex Desktop picker	the `model_catalog_json` bug; the picker has nothing to describe when the model is set inline	Codex Desktop not showing custom models
an unknown model silently caps at 258K context	Codex falls back to a default context size for models not in its catalog	Qwen 3.8 Max in Codex CLI

Pointing Codex at a provider other than OpenAI is a supported path, not a hack, but there are three places to do it and they behave differently. The config.toml reference is the full surface. The [model_providers] block is how you keep several providers side by side. The custom endpoint guide is the two-variable version if you only want one. One constraint that catches people: Codex only accepts wire_api = "responses" for custom providers, so a chat-completions-only gateway will not work no matter how the rest is configured.

Which changes need evidence first?

Changing API keys. For a rejected key, verify the selected provider, credential and account. For a missing-header error, inspect whether the client actually sends authentication. A 429 needs rate-limit or quota checks, not automatic key rotation.

Reinstalling. For a command-not-found error, inspect PATH and the installed binary before reinstalling. Installation damage and path configuration are different causes; use the logs to distinguish them.

An open GitHub issue. An issue still marked open does not mean the feature is missing. Codex issue #22638 asks for Chromium browser support and is still open, while the docs list five supported browsers and the feature shipped. Check the product, then the tracker.

How do you set Codex up from scratch?

If nothing is broken yet and you are here to configure rather than repair:

Install it, on any of npm, Homebrew, the standalone installer, or a raw binary.
Write a config.toml and understand the three approval modes and three sandbox levels before you loosen either.
Point it at the model you actually want, whether that is an OpenAI model or something else through an OpenAI-compatible gateway.
Learn the loop: AGENTS.md, plan mode, worktrees, and the seven mistakes that waste the first week.

Coming from somewhere else, the Claude Code migration maps all 12 config surfaces and names the one dead end. Choosing rather than migrating, Claude Code vs Codex vs Cursor vs DeepSeek TUI and OpenCode vs Codex CLI are the head-to-heads.

What about the browser, mobile and desktop surfaces?

The Chrome extension now covers Chrome, Edge, Brave, Opera and Vivaldi and installs from the ChatGPT desktop app. Codex on iPhone and Android is a remote session, so nothing about PATH or sandboxes applies there. Goal Mode and remote computer use is the long-running agentic mode and its own safety model.

References

Frequently Asked Questions

Why does Codex fail with a different error on Windows than on macOS?

Operating systems and installation methods use different paths, permissions and process launchers. On Windows, os error 3 points to a path lookup failure; inspect the actual executable path and application logs. Do not assume every Windows failure has the same cause.

What should I check before working through any Codex fix?

Your version. Run codex --version for the CLI and check the extension version in your editor. Several of the most-reported 2026 errors are regressions with a known fixed build: the 'couldn't load its resources' family was introduced in 26.803.41515 and fixed in 26.810.41047, and AGENTS.md in symlinked workspaces was fixed in CLI v0.138. Upgrading is the whole fix in those cases.

Is a Codex 401 always an authentication problem?

No. Nine distinct failures return something that looks like a 401, and they split into three groups that need different fixes: no key was sent at all ('Missing bearer or basic authentication in header'), a key was sent and rejected ('Incorrect API key provided'), and a key that is correct but carries a trailing newline from a shell export. The status code is the same; the message body is what tells them apart.

Does hitting the Codex weekly limit mean I have to wait a fixed number of days?

No. The reset is a server-side resetsAt timestamp attached to your account, not a clock rule you can compute, and there are only two windows (primary and secondary). You can read the actual timestamp rather than guessing, and an earned reset credit can be redeemed early.

Which Codex surface am I actually using?

There are five and they fail differently: the CLI (@openai/codex on npm, currently 0.151.0), the editor extension, the Chrome extension driven by the ChatGPT desktop app, Codex inside the ChatGPT mobile app, and the desktop app itself. An error about resources or a native host is an extension problem; an error about config.toml or a sandbox is a CLI problem.

Originally published on ofox.ai/blog.

Connect Codex CLI and Claude Code to Ofox with CC Switch

Owen — Sat, 12 Sep 2026 01:22:26 +0000

CC Switch sets up Codex CLI and Claude Code against Ofox from one place. The two need different base URLs and API formats — mixing them up is the usual failure.

Two clients, two protocols

Codex CLI and Claude Code speak different protocols. CC Switch keeps both entries side by side, which is the main reason to use it — pasting the Claude Code base URL into the Codex tab, or the reverse, is an easy mistake to make by hand.

Feature	Codex CLI	Claude Code
Protocol	OpenAI-compatible	Anthropic native
Ofox base URL	`https://api.ofox.ai/v1`	`https://api.ofox.ai/anthropic`
API format in CC Switch	OpenAI Compatible	Anthropic Messages (Native)
Auth field	not applicable	`ANTHROPIC_AUTH_TOKEN (Default)`
CC Switch tab	Codex	(provider management page)

Neither URL takes a trailing slash, and one Ofox key authenticates both. Note that this table describes the client, not the model — every Claude model in the Ofox catalog, Fable 5.1 included, accepts either protocol.

Installing CC Switch

# macOS
brew install --cask cc-switch

# Debian / Ubuntu — download the .deb from Releases first
sudo dpkg -i <downloaded-file>.deb

# Fedora / RHEL
sudo rpm -i <downloaded-file>.rpm

# AppImage
chmod +x <downloaded-file>.AppImage && ./<downloaded-file>.AppImage

Windows ships an .msi installer, and macOS has a .dmg on the releases page if you would rather not use Homebrew. For the full install walkthrough, see the CC Switch setup guide. Minimum supported versions are macOS 12, Windows 10, and Ubuntu 22.04 / Debian 11 / Fedora 34.

Adding the Codex CLI provider

Switch to the Codex tab at the top, then use the + button in the top-right corner.

Field	Value
Provider Name	`ofoxai-codex`
Website URL	`https://ofox.ai`
API Key	your Ofox key
Request URL	`https://api.ofox.ai/v1`
API Format	OpenAI Compatible
Write to Global Config	checked

Leaving "Write to Global Config" checked applies the provider across all projects rather than just the current one. Add the provider, then activate it from the list.

Adding the Claude Code provider

Same tool, different page and different values.

Field	Value
Provider Name	`ofoxai-claude`
Website URL	`https://ofox.ai`
API Key	your Ofox key
Request URL	`https://api.ofox.ai/anthropic`
API Format / Auth Field	Anthropic Messages (Native) / `ANTHROPIC_AUTH_TOKEN (Default)`
Model Configuration	leave empty
Write to Global Config	checked

Leave Model Configuration empty. It falls through to the default Claude model, which is what you want unless you are deliberately pinning one. CC Switch writes the result to ~/.claude/settings.json.

There are two optional toggles on this page, "Hide AI Signature" and "Teammates Mode". Neither affects routing or billing.

Turning on usage query

CC Switch can poll Ofox for consumption figures and show them in its dashboard. Four things to set: toggle Enable Usage Query on, paste the same Ofox API key, set the request endpoint to https://api.ofox.ai/v1, and pick the Universal Template (通用模板) option, which the Ofox documentation recommends for best compatibility.

Two things to know:

It does not consume API quota — it uses a dedicated statistics API rather than your call budget.
Figures lag the calls that produced them by a few minutes.

Turning it off later does not disturb normal API calls.

On Fable 5.1 specifically

Fable 5.1 landed in the Ofox catalog on 3 September 2026, as anthropic/claude-fable-5.1. Nothing above changes for it: same two base URLs, same two API formats, same key. The model string is the only difference.

The setup is worth doing regardless of which model you land on: it gives you a working two-protocol path where switching models is a string change. Alongside Fable 5.1, the catalog has anthropic/claude-fable-5, anthropic/claude-opus-5 and anthropic/claude-sonnet-5 at Anthropic list prices with no markup, and all four are reachable over either protocol on the same key.

That matters for Fable 5.1 in particular, because its only price change is the cache read — $1 down to $0.25. Whether that is worth anything to you depends entirely on your cache-hit ratio, and the way to find out is to run your real workload through this setup and read the number off your own usage. The API reference has the rate table and the TTL arithmetic.

When something does not connect

Three common failure modes:

A trailing slash on the request URL. The Ofox documentation calls this out for both providers.
The wrong API format for the tab. Codex CLI with "Anthropic Messages (Native)" selected will not work, and neither will the reverse. Check the format field before the key.
A model string the catalog does not have. Note that the Ofox ID for Fable 5.1 is anthropic/claude-fable-5.1 with a dot, not a hyphen — though the alias anthropic/claude-fable-5-1 also resolves. The live catalog is the authority: GET /v1/models returns exactly what you can call.

CC Switch installation targets, provider field values, base URLs and usage-query behaviour verified against the Ofox integration documentation on 3 September 2026. Catalog contents checked against the live /v1/models endpoint the same day.

Frequently Asked Questions

What is CC Switch?

An open-source provider manager with a visual interface. It writes the config files for Claude Code and Codex CLI, so you do not have to edit JSON or environment variables by hand. For Claude Code it writes ~/.claude/settings.json. It runs on macOS 12+, Windows 10+, and Ubuntu 22.04+ / Debian 11+ / Fedora 34+.

Do Codex CLI and Claude Code use the same Ofox base URL?

No — and this is where setups usually go wrong. Codex CLI is an OpenAI-protocol client and takes https://api.ofox.ai/v1 with the API format set to OpenAI Compatible. Claude Code is an Anthropic-protocol client and takes https://api.ofox.ai/anthropic with the format set to Anthropic Messages (Native). Neither URL takes a trailing slash.

Can I run Claude Fable 5.1 through this setup?

Yes, as of 3 September 2026. Fable 5.1 is in the Ofox catalog as anthropic/claude-fable-5.1. Nothing in the setup changes for it — same base URLs, same API formats, same key. Only the model string differs.

Does CC Switch's usage query burn API quota?

No. Per the Ofox integration documentation it uses a dedicated statistics API and does not count against your API call limits. Usage figures typically appear within a few minutes of the calls that produced them.

Can I keep more than one Ofox account in CC Switch?

Yes. You can add multiple Ofox provider entries with different API keys and switch between them from the list.

Originally published on ofox.ai/blog.

ChatGPT DeviceCheck Registration Failed (403, 500, 503): Real Fixes

Owen — Mon, 07 Sep 2026 04:34:54 +0000

ChatGPT DeviceCheck Registration Failed (403, 500, 503): Real Fixes

DeviceCheck errors block ChatGPT login before your password is ever checked, and the official advice about date and time fixes almost none of them. The error means your device could not produce an attestation token proving it is genuine hardware. That is a conversation between your device and Apple or Google — OpenAI is only the party that gets told "no".

Which is why the same account signs in fine on the website. This page covers what each variant means and the fixes that actually resolve reports, ordered by how often they work.

Error family:   DeviceCheckError / "DeviceCheck registration failed"
Also seen as:   Token generation failed · Preauth PlayIntegrity verification failed
                DeviceCheck token generation is unavailable (macOS)
Codes attached: 403, 500, 503 — these are transport codes, not distinct root causes
Blocks:         native app login only. Browser login is unaffected.
Root cause:     device attestation, not your OpenAI account

Sources are OpenAI's own help article, OpenAI Developer Community threads, and openai/codex issue #33463. Read 6 September 2026.

What DeviceCheck Actually Is

Apple's DeviceCheck and Google's Play Integrity let an app ask the OS vendor "is this a real, unmodified device?" OpenAI uses that to stop bulk account creation on emulators and modified phones.

The sequence when it fails:

You tap Log in. The app asks the OS for an attestation token.
The OS tries to produce one, talking to Apple or Google in the process.
Something in that chain fails.
The app never gets a token, so it never sends your credentials, and you see a DeviceCheck error.

Your account is never involved. That is the single most useful thing to understand here, because it rules out password resets, account recovery and support tickets about billing — none of which touch this.

The 403, 500 and 503 in the search results

People search for devicecheck registration failed (403), (500) and (503) because those numbers appear in the error text. They are HTTP statuses from the attestation call, not separate bugs with separate fixes:

403 — the request was rejected. Usually integrity: a modified device, or an edge/WAF layer refusing the client. Several iPhone reports trace 403 to a Cloudflare challenge during login.
500 / 503 — the attestation service failed or was unavailable. Often transient on the provider side.

If you see 503, wait and retry before changing anything. If you see 403 repeatedly, it is more likely one of the device-side causes below.

Fix 1: Clear Your Browser Cache (Most Reported Success)

The ChatGPT app hands login to your system browser, so a poisoned browser cache breaks the app while the website still works.

This is counterintuitive enough that people skip it, and it is the fix that resolves the most reports.

iPhone: clear the cache in both Safari and Chrome, not just your default.

Settings → Safari → Clear History and Website Data
Chrome → ⋯ → Delete Browsing Data

Android: switch your default browser to Chrome and retry. Multiple reports resolve immediately on moving off Brave or a custom browser.

One community report after months of failed attempts: after clearing both Safari and Chrome caches, "it magically started working perfectly." The mechanism is that login runs through the system browser in the background, so the browser's state is the app's state.

Fix 2: Install Pending OS Updates, Then Restart

A pending security update that could not install is a documented cause.

One iPhone report worked through switching Wi-Fi, hotspot, reinstalling, private mode, and logging out and in — none of it helped. The actual cause was an iOS update blocked by low storage. After freeing space, installing, and letting the phone reboot, login worked immediately.

Check Settings → General → Software Update, install anything pending including security responses, and restart before trying again. Outdated security components can cause the edge layer to reject the device during login.

Fix 3: Device Integrity (And Why Retrying Does Not Help)

If your device is rooted or jailbroken, DeviceCheck failing is the system working as designed. OpenAI's help article names this directly: "Modifications like rooting or jailbreaking may cause this error."

The detail that wastes people's time is in the same article: integrity check results can be cached for up to 24 hours. So if you fix the underlying problem and retry immediately, you are testing against a cached failure. Clear the app data before retrying.

On rooted Android with Magisk, the community fix is the Play Integrity Fix module, then reboot. That is a workaround for a check that is deliberately failing, so treat it accordingly.

Fix 4: Clear App and Play Services Data (Android)

Ordered from least to most disruptive:

Settings → Apps → ChatGPT → Storage → Clear cache
Same screen → Clear data (this signs you out)
Settings → Apps → Play Store → Clear data
Settings → Apps → Google Play Services → Clear cache

Then reboot and retry. Doing all four at once works but tells you nothing about the cause; going in order costs a few minutes and identifies it.

Fix 5: macOS "DeviceCheck Token Generation Is Unavailable"

This variant has a different root cause from every fix above, and none of them will resolve it.

The macOS symptom is distinct: authentication succeeds, the app launches and restores your session, and then Chat fails. From the diagnostics in openai/codex issue #33463, the system logs show:

failed to do a bootstrap look-up: xpc_error=[3: No such process]
Could not find service "com.apple.devicecheckd" in domain for system

preauth_cookie_failed=APIClient.DeviceCheckError: Token generation failed
MobileActivation.ErrorDomain Code=-4 "UCRT is unavailable."
devicecheckd: Failed to fetch client certificate.

One reporter confirmed no HTTP 401, no 403 and no TLS failures — the failure is after authentication, during initialisation. The Secure Enclave key generation and attestation steps succeed; what fails is MobileActivation supplying the client certificate DeviceCheck needs.

What resolved it in that thread:

A plain reboot, for two reporters on an older app version.
Updating macOS and restarting. One persistent case survived 26.5 → 26.6 and multiple app updates, then recovered on 26.6.1 with a restart. The logs flipped to Performing UCRT OOB. Successfully performed UCRT OOB. and devicecheckd immediately obtained new attestation certificates.
That same reporter had also changed their Apple Account password and could not tell which action fixed it.

What did not help: creating a new macOS user account (the failure followed), and toggling Find My.

If you are hitting this, update macOS and restart first. It is an Apple-side certificate problem, so reinstalling ChatGPT is not the lever.

What to Do While It Is Broken

Log in through a browser. The web app does not require device attestation, which is exactly why it keeps working when the native app does not. Every community thread on this confirms the website is unaffected.

If you signed up with email and password, do not try Google, Microsoft or Apple sign-in on the app — mixing methods causes its own separate failure. Use the same method you registered with.

If you need API access rather than the consumer app, DeviceCheck is not in the path at all. API keys authenticate with a bearer token and never touch device attestation, so this class of error cannot occur:

curl -X POST https://api.ofox.ai/v1/chat/completions \
  -H "Authorization: Bearer $OFOX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "messages": [{"role": "user", "content": "..."}]
  }'

That is a different product from the ChatGPT app, not a workaround for it — worth knowing only if what you actually needed was programmatic access.

What Does Not Fix It

Collected from threads where people tried these repeatedly without success, so you can skip them:

Reinstalling the app. Frequently tried, rarely the fix, and on macOS it cannot be the fix because the problem is in Apple's certificate chain.
Password resets and account recovery. Your credentials are never sent. The failure is upstream of them.
Switching Wi-Fi to cellular. Occasionally helps if a network is genuinely blocking the attestation endpoint, but it is far down the list.
Retrying immediately after a change. Integrity verdicts cache for up to 24 hours. Clear app data or you are re-reading a stale result.

One more, for completeness: a firewall can cause this. One macOS user resolved it by allowing ChatGPT four specific connections in Little Snitch. If you run a per-app firewall, check it before anything else on this page.

Related Errors

If your problem is authentication rather than attestation, these are different failures with different fixes:

Codex CLI 401 Unauthorized — a real credential rejection, unlike DeviceCheck.
codex: command not found and EACCES — install-path problems, not login.
Codex "failed to start app-server" on Windows — the Windows desktop equivalent of "the app will not start", with a completely separate cause list.

Sources

Official causes and the 24-hour integrity cache note are from OpenAI's help article. The macOS devicecheckd / UCRT diagnostics and the recovery accounts are quoted from openai/codex issue #33463. Remaining fixes are drawn from OpenAI Developer Community threads where a reporter confirmed the fix worked; they are community reports rather than vendor-documented solutions, and none of this is our own reproduction — DeviceCheck failures depend on individual device state and cannot be reliably reproduced on demand.

Frequently Asked Questions

What does DeviceCheck registration failed mean in ChatGPT?

It means the app could not generate a device attestation token, so OpenAI cannot verify the device is genuine and blocks the login before your credentials are ever checked. DeviceCheck is Apple's device-integrity API and Play Integrity is the Android equivalent. The failure is about your device's relationship with Apple or Google, not about your OpenAI account, which is why the same account signs in fine in a browser.

Why does OpenAI tell me to check my date and time?

Because attestation tokens are time-sensitive and a badly skewed clock will break them. That is a real cause but a rare one. In practice most reports come from a stale browser cache, a pending OS update, a modified device that fails integrity checks, or on macOS a broken devicecheckd certificate. Set the clock to automatic, then move on to the causes below rather than retrying.

How do I fix DeviceCheck error on iPhone?

Clear the Safari and Chrome caches first. The ChatGPT app hands login to the system browser, so a poisoned browser cache breaks the app while the website still works. Then install any pending iOS update and restart; several reports trace the failure to a security update that could not install for lack of storage. If it persists, sign in through the browser and use a different sign-in method than the one that is failing.

How do I fix DeviceCheck error on Android?

Switch your default browser and retry — reports resolve on Android by moving from Brave or a custom browser to Chrome, because login is handed to the default browser. Then clear the ChatGPT app cache and data, and clear Play Store and Play Services data. If the device is rooted, Play Integrity will fail by design; that is the cause, not a bug.

What causes DeviceCheck token generation is unavailable on macOS?

A broken Apple attestation chain rather than anything in ChatGPT. In openai/codex issue #33463 the logs show devicecheckd failing to reach com.apple.devicecheckd, then MobileActivation error code -4, UCRT is unavailable, and Failed to fetch client certificate. Authentication itself succeeds with no 401 or 403; the failure happens after login during initialisation. Reporters recovered by updating macOS and restarting, one after refreshing the Apple Account password.

Does a jailbroken or rooted device cause DeviceCheck errors?

Yes, and OpenAI says so directly. Its help article lists device integrity as a cause and notes that rooting or jailbreaking may trigger the error. It also warns that integrity check results can be cached for up to 24 hours, so clear the app data before retrying or you will be testing against a stale verdict.

Can I use ChatGPT while DeviceCheck is broken?

Yes. Log in through a browser — the web app does not require device attestation, which is why it keeps working when the native app does not. If you need API access rather than the consumer app, an OpenAI-compatible gateway such as api.ofox.ai is unaffected because API keys do not go through DeviceCheck at all.

Originally published on ofox.ai/blog.

Fable 5.1 vs Fable 5 vs Opus 5: It's All in the Cache

Owen — Sun, 06 Sep 2026 11:33:11 +0000

Fable 5.1 vs Fable 5 vs Opus 5: It's All in the Cache

Claude Fable 5.1 shipped on 1 September 2026 as the cheaper Fable. Base rates did not move: input is still $10 per million tokens and output $50, the same as Fable 5. The entire cut is one line, cache reads, $1 to $0.25. That 75% cut is what Anthropic's estimates of 25% for typical workloads and up to 45% for agentic ones rest on.

It reaches your invoice only in proportion to how much of your input is actually served from cache. Read the price table before acting on the headline.

The table everyone is skipping

Anthropic publishes five rates per model, and most summaries quote one. Here is the whole thing, in dollars per million tokens:

Model	Base input	5m cache write	1h cache write	Cache read	Output
Fable 5.1	10	12.50	20	0.25	50
Fable 5	10	12.50	20	1.00	50
Opus 5	5	6.25	10	0.50	25
Sonnet 5	2	2.50	4	0.20	10

Read the two Fable rows side by side. Four of the five numbers are identical. Fable 5.1 is not a cheaper model — it is the same model at the same price, with a cheaper cache.

What that means for your bill

Cache savings compound with reuse, which is why one rate change lands so differently across workloads. Take one 1M-token prefix — a codebase, a document set, a long system prompt — write it to cache once, then read it back N times. The no-caching column is what the same N+1 full passes cost at $10 per million:

Reads	Fable 5	Fable 5.1	No caching	5.1 advantage
1	$13.50	$12.75	$20.00	1.06x
10	$22.50	$15.00	$110.00	1.50x
100	$112.50	$37.50	$1,010.00	3.00x
500	$512.50	$137.50	$5,010.00	3.73x

Assumes a single 5-minute cache write with no expiry between reads — reads refresh the entry for free, so this holds for a continuously active agent. If the prefix goes cold and has to be rewritten, add $12.50 per rewrite to both Fable columns; see the TTL section below.

At one read the two versions are within 6% of each other. At a hundred reads Fable 5.1 costs a third of what Fable 5 costs. Nothing about the model changed between those rows — only how many times you came back to the same cached context.

This is why Anthropic's two figures sit so far apart. A workload that touches cached context a handful of times per session lands near 25%. A long-running agent that re-reads the same repository hundreds of times over an afternoon is what the "up to approximately 45%" end of that range describes. To know which applies to you, count cache hits, not requests.

Take a concrete case: 1M input tokens of which 90% are cache reads, plus 20K output.

Fable 5 — $0.90 cache + $1.00 fresh input + $1.00 output = $2.90
Fable 5.1 — $0.225 cache + $1.00 fresh input + $1.00 output = $2.225

A 23% saving, lining up with Anthropic's estimated 25% for typical usage. Note where it comes from: the cache line fell by three quarters, but it was only about 31% of the bill to begin with.

The TTL choice costs more than the price cut

Anthropic sells two cache-write durations, and this is the part most cost models leave out. A 5-minute cache write is $12.50 per million tokens; a 1-hour write is $20.

The 5-minute clock is looser than it sounds. Anthropic's prompt-caching documentation is explicit: "The cache is refreshed for no additional cost each time the cached content is used." The lifetime is measured from the start of each request that writes or reads the entry. An agent hammering the same prefix continuously keeps a 5-minute entry alive on reads alone and pays for exactly one write.

The money leaks in the gaps. A planning turn, slow tool calls, a human reviewing a diff — any quiet stretch longer than five minutes lets the entry expire, and the next call pays the write again. An hour of that pattern costs at worst 12 × $12.50 = $150, against $20 for a single 1-hour write.

That worst case is a $130 gap per prefix per hour, larger than the entire cache-read reduction Fable 5.1 shipped — and it is decided by the shape of your traffic, not by which model you picked. A continuously busy agent may never reach it; one that idles between turns will. Work out which you are running before you bank the new pricing.

Fable 5.1 versus Opus 5: the trap in the numbers

One line does invert: Fable 5.1 reads cached tokens at $0.25, half of Opus 5's $0.50 — even though Fable's base input is twice Opus 5's and its output is twice as expensive too.

It is tempting to conclude that cache-heavy agents should now move up to Fable. The algebra says otherwise. With input I, cache-read fraction f, and output O, Fable 5.1 is cheaper only when:

10(1−f)·I + 0.25f·I + 50·O  <  5(1−f)·I + 0.50f·I + 25·O
→  5I − 5.25f·I + 25O < 0
→  f > (5 + 25·(O/I)) / 5.25

Set output to zero — a workload producing nothing at all — and you still need f > 95.2%. Every token you actually generate pushes the threshold higher. There is no realistic mix in which Fable 5.1 undercuts Opus 5 on total cost.

The worked example above shows it plainly: Fable 5.1 costs $2.225 and Opus 5 costs $1.45 for identical traffic. One cheaper line does not carry a model that is 2x on everything else.

So the decision does not change, it just costs less on one axis: choose Fable 5.1 when you need its capability, not to undercut Opus 5 on cost. What the new cache pricing buys is that the premium for staying on a Mythos-level model through a long agentic run is smaller than it was on Fable 5.

An independent measurement points the same way

Artificial Analysis, which supported Anthropic with pre-release evaluation of the model, published cost-per-task figures on 1 September that land on exactly this point. Their headline: Fable 5.1 "tops the Artificial Analysis Intelligence Index but costs 20% more per task than Fable 5 despite a 75% cache read price cut".

Model (max effort)	Intelligence Index	Cost per task
Fable 5.1	66	$3.76
Opus 5	63	$2.34
Fable 5	62	$3.14

The reason is the half of the equation this article has been circling: Fable 5.1 uses roughly 1.7x the output tokens of Fable 5 at max effort. Output is the $50 line, and no discount on the $0.25 line reaches it. A cheaper cache did not make it a cheaper model — measured end to end on the same task set, it got 20% more expensive than its own predecessor and 1.6x Opus 5.

It also scored highest of anything they have measured. That is the actual trade: you are buying the top of the index and paying more per task than before, not less.

What Anthropic says changed besides price

The Claude Fable product page is specific about behavior rather than benchmarks. It says Fable 5.1 "avoids easy-seeming shortcuts, fixes the root causes of problems rather than the symptoms, and keeps you updated as it works". (The separate launch announcement words this differently, so it is worth naming which page a quote comes from.) The strongest concrete claim is not Anthropic's own. Josh Boyer, Distinguished Engineer at Red Hat, is quoted on the same page: "Using Claude Code, it correctly identified the root cause of every broken build we tested, across all the effort levels."

The first is the vendor describing its own model; the second is a customer describing its own tests. Neither is a benchmark, and both are worth reproducing on your own broken builds before you rewrite a routing policy around them. Anthropic's announcement page does carry a full benchmark table — Terminal-Bench-Science, Terminal-Bench, OSWorld, HLE and more. This piece deliberately leaves those alone and sticks to the money, because the cost story is the one the launch coverage got wrong.

Two safeguard changes are easy to conflate, and several write-ups have. On 7 August 2026 Anthropic retuned Claude Fable 5's biology safeguards and reported that the update "reduced biology-related fallbacks by about 85% across our product surfaces". Separately, the 1 September launch announcement says that in cybersecurity Fable 5.1's "newest safeguards block 60% fewer false positives than before". So "fewer false positives" is a genuine 5.1 launch claim — on the cyber side. It is not the August biology change, and the two numbers should not be added together.

Specs, and a detail that gets overlooked

	Fable 5.1	Opus 5	Sonnet 5
Thinking	Adaptive (always on)	Adaptive	Adaptive
Default effort	high	high	high
Context window	1M	1M	1M
Max output	128K	128K	128K
Reliable knowledge cutoff	Jun 2026	May 2026	Jan 2026

The model ID is claude-fable-5-1. Context and output limits are identical across all three, so the differentiators are price, behavior, and that last row — Fable 5.1 has the most recent reliable knowledge cutoff of the three models here, a month ahead of Opus 5 and five months ahead of Sonnet 5. For anything touching recent library versions or APIs, that gap does real work.

Mythos 5.1 appears in the same pricing table at identical rates. Anthropic's announcement states the two "are the same underlying model" and that the gap between them "reflects the tasks on which our earlier, less precise cyber safeguards intervened". Access runs through trusted-access programs, and the two are not at the same stage: the Life Sciences Verification Program is an invite-only beta that grants access now, while the Cyber Verification Program currently covers Opus- and Sonnet-class models with reduced cyber safeguards. Of Mythos, Anthropic writes: "In the near future, this program will also include access to Claude Mythos-class models." Availability is currently limited to a set of US organizations. Not a drop-in option for general use.

Picking one

Your workload	Take
Long agentic runs, heavy cache reuse, hardest tasks	Fable 5.1 — the premium is smaller now, but it is still a premium (on Ofox as `anthropic/claude-fable-5.1`)
Complex agentic coding, enterprise work, cost matters	Opus 5 — cheaper on every realistic mix
High volume, latency-sensitive, good enough quality	Sonnet 5 — $2/$10 with the same 1M context
Already on Fable 5	Same base price, cheaper cache, newer cutoff — worth moving. Now in the Ofox catalog as `anthropic/claude-fable-5.1`

Then go and check your cache TTL. On an hour-long agent that single setting swings more money than the price change this article is about.

Availability

Fable 5.1 was added to the Ofox catalog on 3 September 2026, as anthropic/claude-fable-5.1 (the alias claude-fable-5-1 also resolves). All five rates match Anthropic's list prices with no markup, so every figure in this article applies unchanged. It sits alongside anthropic/claude-fable-5, anthropic/claude-opus-5 and anthropic/claude-sonnet-5, and all four are reachable on a single Ofox key over either protocol — the OpenAI-compatible base URL https://api.ofox.ai/v1, or the native Anthropic base URL https://api.ofox.ai/anthropic.

Prices and specifications verified against Anthropic's pricing, model documentation, product page and launch announcement on 2 September 2026 and re-checked on 3 September 2026. Cost-per-task figures from Artificial Analysis, published 1 September 2026.

Frequently Asked Questions

Is Claude Fable 5.1 cheaper than Fable 5?

Only on cached input. Base input stays at $10 per million tokens and output stays at $50, both identical to Fable 5. The one line that changed is cache reads, from $1 to $0.25 per million tokens. Anthropic states this is 75% less and reduces the cost of typical workloads by an estimated 25%, and highly agentic workloads by up to approximately 45%. If your workload rarely reads from cache, your bill barely moves.

Fable 5.1 cache reads cost less than Opus 5's. Does that make it cheaper overall?

No. Fable 5.1 reads cached tokens at $0.25 against Opus 5's $0.50, but its base input ($10 vs $5) and output ($50 vs $25) are both double. Working the algebra through, Fable 5.1 only wins on total cost when cache reads exceed roughly 95% of your input and output is close to zero. That is not a real workload. Pick Fable 5.1 for capability, not to undercut Opus 5 on cost.

What is the Claude Fable 5.1 model ID and context window?

The model ID is claude-fable-5-1. It has a 1M-token context window, 128K maximum output, adaptive thinking always on, and a default effort level of high. Its reliable knowledge cutoff is June 2026, one month later than Opus 5 and five months later than Sonnet 5.

What is Claude Mythos 5.1?

Anthropic states that Mythos 5.1 and Fable 5.1 are the same underlying model, differing in safeguards, and lists them at identical rates. Mythos runs through trusted-access programs at different stages — the Life Sciences Verification Program is an invite-only beta granting access now, while the Cyber Verification Program will include Mythos access in the near future — and availability is currently limited to a set of US organizations, so it is not something you can simply call from a standard API key.

Can I call Fable 5.1 through Ofox today?

Yes. Fable 5.1 was added to the Ofox catalog on 3 September 2026 as anthropic/claude-fable-5.1, at Anthropic list prices with no markup — all five rates match. It is reachable over either the OpenAI-compatible or the native Anthropic protocol on the same key as Fable 5, Opus 5 and Sonnet 5.

Originally published on ofox.ai/blog.

Claude Fable 5.1 API: Model ID, Rates, Effort and Cache TTL

Owen — Sun, 06 Sep 2026 00:33:13 +0000

Claude Fable 5.1 API: Model ID, Rates, Effort and Cache TTL

Claude Fable 5.1 shipped on 1 September 2026. This post is the reference: the identifiers, the five published rates, and the cache-TTL choice that costs more than the price cut saves. For the cost argument against Opus 5, see Fable 5.1 vs Fable 5 vs Opus 5.

The identifiers

Field	Value
Model ID	`claude-fable-5-1`
Context window	1M tokens
Max output	128K tokens
Thinking	Adaptive, always on
Default effort	high
Reliable knowledge cutoff	June 2026

Adaptive thinking cannot be switched off on this model. That matters for budgeting, because thinking tokens are billed as output — the $50 line, not the $10 line.

All five rates

Anthropic publishes five rates per model. Most write-ups quote one of them. Dollars per million tokens:

Rate	Fable 5.1	Fable 5	Opus 5	Sonnet 5
Base input	10	10	5	2
5m cache write	12.50	12.50	6.25	2.50
1h cache write	20	20	10	4
Cache read	0.25	1.00	0.50	0.20
Output	50	50	25	10

Read the two Fable columns against each other. Four of the five numbers are identical. The version bump moved exactly one line.

Effort does not change the rate — it changes the token count

Effort is not a pricing tier. The per-token rates above hold at every effort level. What effort changes is how much the model writes before it answers.

Artificial Analysis, which took part in pre-release evaluation of the model, measured Fable 5.1 at max effort using roughly 1.7x the output tokens of Fable 5. Output is the $50 line. That is why their cost-per-task figure came out at $3.76 against Fable 5's $3.14 — 20% higher — even though the cache read got 75% cheaper.

So the budgeting rule is: raising effort raises your bill through volume, not through rate. If you are cost-sensitive, cap effort before you optimize anything else.

What caching is worth

A cache read at $0.25 is one-fortieth the price of base input at $10. The saving compounds with reuse.

Take one 1M-token prefix — a codebase, a document set, a long system prompt. Write it once, read it back N times:

Reads	Fable 5.1	Fable 5	No caching
1	$12.75	$13.50	$20.00
10	$15.00	$22.50	$110.00
100	$37.50	$112.50	$1,010.00
500	$137.50	$512.50	$5,010.00

The table assumes a single 5-minute write with no expiry between reads. The "no caching" column is the same N+1 full passes at $10 per million.

At a single read the two versions are within 6% of each other. At a hundred reads Fable 5.1 costs a third of Fable 5. The model is identical across those rows; only the cache-hit count changes. That is the number to measure.

The TTL decision

Anthropic sells two cache-write durations: $12.50 per million for five minutes, $20 for an hour. The five-minute clock resets on reads. Anthropic's prompt-caching documentation is explicit that the cache is refreshed for no additional cost each time the cached content is used, and that the lifetime is measured from each request that writes or reads the entry. An agent that keeps hitting the same prefix holds a five-minute entry open on reads alone and pays for exactly one write.

The money leaks in the gaps. Any pause over five minutes — a slow tool call, a human reading a diff — lets the entry expire, and the next call pays the write again. An hour of that costs at worst 12 × $12.50 = $150, against $20 for one 1-hour write.

That $130 gap per prefix per hour is decided by your traffic pattern rather than your model choice, which is why it survives the version bump entirely.

Migrating from Fable 5

The change is a string. Base rates, context window, output ceiling and default effort are all unchanged, so a swap of the model ID is the whole migration:

- model="claude-fable-5"
+ model="claude-fable-5-1"

Two things to re-check after the swap, because neither is visible in the diff:

Your output budget. Same rate, but Artificial Analysis measured roughly 1.7x the output tokens at max effort. If you had alerts calibrated on Fable 5's output volume, they will fire.
Your knowledge-cutoff assumptions. A June 2026 cutoff means prompts that patched around stale library knowledge may now be redundant or, worse, actively wrong.

What Anthropic says changed besides price

The Claude Fable product page describes behavior rather than benchmarks. It says Fable 5.1 "avoids easy-seeming shortcuts, fixes the root causes of problems rather than the symptoms, and keeps you updated as it works".

Two safeguard changes are easy to conflate, and several write-ups have. On 7 August 2026 Anthropic retuned Fable 5's biology safeguards and reported that the update "reduced biology-related fallbacks by about 85% across our product surfaces". Separately, the 1 September launch announcement says that in cybersecurity Fable 5.1's "newest safeguards block 60% fewer false positives than before". So "fewer false positives" is a genuine 5.1 launch claim — on the cyber side. It is not the August biology change, and the two numbers should not be added together.

Calling it through Ofox

Fable 5.1 is in the Ofox catalog as of 3 September 2026, listed as anthropic/claude-fable-5.1. The alias claude-fable-5-1 — Anthropic's own model ID — also resolves, so a migration from Anthropic direct needs no string change beyond the provider prefix.

The same key also covers anthropic/claude-fable-5, anthropic/claude-opus-5 and anthropic/claude-sonnet-5, all at Anthropic list prices with no markup. All four are reachable over either protocol:

Protocol	Base URL
OpenAI-compatible	`https://api.ofox.ai/v1`
Anthropic native	`https://api.ofox.ai/anthropic`

The native path gives you the Messages API. Ofox's documentation lists extended thinking and tool use on it explicitly but does not call out caching separately, so check that usage.cache_read_input_tokens is non-zero on your first repeated call before you bank the TTL arithmetic above.

import anthropic

client = anthropic.Anthropic(
    base_url="https://api.ofox.ai/anthropic",
    api_key="<OFOX_API_KEY>",
)

message = client.messages.create(
    model="anthropic/claude-fable-5.1",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize this repository."}],
)

All five rates match Anthropic's list with no markup, so every figure in this article applies unchanged. What still decides whether the cheaper read is worth anything to you is your cache-hit ratio — measure that on your own traffic before you assume the 25% lands.

Rates and specifications verified against Anthropic's pricing documentation, model overview, product page and launch announcement on 3 September 2026. Cost-per-task figures from Artificial Analysis, retrieved the same day. Ofox catalog and protocol base URLs checked against the live /v1/models endpoint and the Ofox documentation on 3 September 2026.

Frequently Asked Questions

What is the Claude Fable 5.1 model ID?

claude-fable-5-1. It has a 1M-token context window and produces up to 128K output tokens. Adaptive thinking is always on and cannot be turned off, and the default effort level is high. The reliable knowledge cutoff is June 2026.

What does Claude Fable 5.1 cost?

Anthropic publishes five rates per million tokens: $10 base input, $12.50 for a 5-minute cache write, $20 for a 1-hour cache write, $0.25 for a cache read, and $50 output. Four of those five are identical to Fable 5 — only the cache read changed, from $1 to $0.25.

Does raising the effort level change the price per token?

No. The per-token rates are fixed. What changes is how many output tokens the model produces. Artificial Analysis measured Fable 5.1 using roughly 1.7x the output tokens of Fable 5 at max effort, which is why its cost per task came out 20% higher despite the cheaper cache.

Should I use the 5-minute or the 1-hour cache TTL?

It depends on whether your agent idles. Anthropic's documentation states the cache is refreshed for no additional cost each time the cached content is used, and the lifetime restarts on every request that writes or reads the entry. A continuously busy agent keeps a 5-minute entry alive on reads alone. One that pauses longer than five minutes pays the write again — at worst 12 rewrites an hour, $150 against $20 for a single 1-hour write.

Can I call Fable 5.1 through Ofox today?

Yes, as of 3 September 2026. The Ofox catalog lists it as anthropic/claude-fable-5.1, with claude-fable-5-1 as an alias. All five rates match Anthropic's list prices with no markup, and it is callable over either the OpenAI-compatible or the native Anthropic protocol on one key.

Originally published on ofox.ai/blog.

Video Generation API Polling: 202, polling_url, Wait Times (2026)

Owen — Fri, 28 Aug 2026 04:38:10 +0000

The 202 arrives in under a second. The video takes another two to four minutes, and how long is not something you can predict from the request. Everything hard about video generation APIs lives in the gap between those two facts.

Submit:        POST /v1/videos -> 202 in 0.82s
Response body: {id, status: "queued", polling_url}   three fields, nothing else
Wait, 5s clip: 83.3s to 253.2s across 8 identical jobs, median 104.6s
Poll limit:    5 req/s per key, burst 20, 429 + Retry-After: 1 over it
Terminal:      completed | failed | cancelled | expired   (all four, or you spin)
Cancel:        400 cancel_failed once upstream is running
Result URL:    unsigned_urls signed for 24h. mirror_urls absent on Seedance.
Measured:      2026-08-24, 13 jobs through POST /v1/videos

Last updated 2026-08-24. Timings are from one afternoon on one route and will not match yours; the shape of the distribution is the transferable part, not the seconds.

What Does POST /v1/videos Actually Return?

A 202 with three fields. No video, no percentage, no estimate:

{
  "id": "5e6f69b1-8ffe-430c-a687-8241366a90f5",
  "status": "queued",
  "polling_url": "https://api.ofox.ai/v1/videos/5e6f69b1-8ffe-430c-a687-8241366a90f5"
}

That call took 0.82 seconds. The polling_url is a convenience: it is the same GET /v1/videos/{id} you would build yourself, and the Create Video reference says as much. Use the field rather than string-building the URL, because the id format is a UUID today and there is no promise it stays one.

While a job is in flight, the status body is deliberately thin:

{"id": "...", "status": "in_progress", "model": "bytedance/seedance-2.0-mini",
 "prompt": "...", "created_at": 1787567608, "updated_at": 1787567608}

There is no progress field to render a bar from. If your UI needs one, it has to be a fake based on elapsed time against a historical median, and after reading the next section you will understand why that bar has to be honest about being a guess.

When the job completes, two keys appear: unsigned_urls and usage.

One 4-second 480p clip, start to finish. The 8-job table below is a separate set of 5-second clips, so read the 105.9 seconds here as one more sample rather than a row of that table.

How Long Does a Video Generation Job Actually Take?

83 to 253 seconds for the same request. Eight jobs, all 5-second 480p clips on bytedance/seedance-2.0-mini, all through one key on one afternoon:

Run	What it was	Seconds to terminal
1	text-to-video, 16:9	83.3
2	text-to-video, 9:16, one of three submitted together	85.1
3	two reference images	95.6
4	first and last frame, ratio set	103.9
5	first and last frame, no ratio	105.3
6	text-to-video, 9:16, one of three submitted together	126.7
7	text-to-video, 16:9	139.9
8	text-to-video, 9:16, one of three submitted together	253.2

Median 104.6 seconds. Slowest over fastest: 3.0x. The three slowest and the three fastest are not separated by anything in the request; runs 2, 6 and 8 are the same model, the same duration, the same resolution and the same aspect ratio, submitted in the same second, and they finished 85s, 127s and 253s later.

Two practical consequences.

Set the timeout at the tail. A 120-second client timeout would have killed run 8 with the job still generating upstream and still billing. We use 900 seconds as a hard ceiling and treat anything past 300 as worth logging.

Do not promise an ETA. A queue of clips finishes when it finishes. If your product shows a countdown, base it on a rolling median of your own recent jobs and let it overrun rather than lie.

Larger models are not automatically slower, which surprises people. On the same afternoon, a 5-second 480p job on bytedance/seedance-2.5 finished in 53.1 seconds, faster than every Mini run above, while its first-and-last-frame variant took 212.9 seconds. Mode moves the number more than model tier does. The first and last frame walkthrough has the rest of that comparison.

How Often Should You Poll?

Every 2 to 5 seconds. The status endpoint documents a per-key limit of 5 requests per second with a burst of 20; over it you get 429 rate_limited with a Retry-After: 1 header. Creating and cancelling are exempt. The docs also ask for no faster than once per second, so there is a comfortable band between "polite" and "throttled".

At 2 to 3 second intervals across the runs in this article, no poll returned an error.

import time, requests

H = {"Authorization": "Bearer YOUR_OFOX_API_KEY"}
TERMINAL = {"completed", "failed", "cancelled", "expired"}

def wait(job, timeout=900, interval=3):
    t0 = time.time()
    while True:
        s = requests.get(job["polling_url"], headers=H).json()
        if s["status"] in TERMINAL:
            return s
        if time.time() - t0 > timeout:
            raise TimeoutError(f"{job['id']} still {s['status']} after {timeout}s")
        time.sleep(interval)

Three things that loop gets right and most published examples get wrong. It breaks on all four terminal states. It has a ceiling, so a stuck job cannot hang a worker forever. And it reads polling_url from the submit response instead of rebuilding it.

Which Statuses Are Terminal?

Four out of seven. The documented state machine:

Status	Terminal	Meaning
`pending`		Accepted, not yet submitted upstream
`queued`		Submitted upstream, waiting in a queue
`in_progress`		Generating
`completed`	✓	Video URLs available
`failed`	✓	Failed, including timeouts, which arrive as `error.code: "expired"`
`cancelled`	✓	Cancelled
`expired`	✓	Expired

There is no processing. Loops copied from other vendors' SDKs often check for it and then wait forever.

In practice we never observed pending. How long queued lasts moves around: in most of our runs the first poll, 0.3 seconds after submit, already said in_progress, while the run in the screenshot above sat in queued for 14 seconds first. Neither is a bug, it is queue depth. Handle pending anyway; the state you never see in testing is the one that turns up the week you scale.

A note on the timeout case. A generation that times out arrives as failed with error.code: "expired", not as the standalone expired status, so both spellings of the same word exist and mean different things. Branch on error.code, which the error reference describes as the stable field to match on, rather than on message text.

Can You Cancel a Running Video Job?

Usually not, and the refusal is the honest answer. We submitted a job, waited six seconds, and sent DELETE /v1/videos/{id}:

{"error": {"code": "cancel_failed",
  "message": "upstream cancel failed: cancel failed: status 409, body:
    {\"error\":{\"code\":\"InvalidAction.RunningTaskDeletion\",
     \"message\":\"Cannot delete task `cgt-...` because it is currently running.\"}}"}}

Two things worth knowing before you build a stop button.

The docs describe cancel_failed as the code for a job already in a terminal state, and cancel_not_supported for providers that cannot interrupt. What we hit was neither: a running job whose provider refused the deletion, surfaced as cancel_failed carrying the upstream 409. If you branch on that code, allow for both meanings.

And at that exact moment, GET still reported the job as queued. So queued in the status body does not imply the job is cancellable, because the upstream had already started. There is no status you can read that reliably tells you a cancel will work. Try it, check for 204, and if you get a 400 assume you are paying for the clip.

The design conclusion is unpopular but simple: treat submission as the commit point. Validate the prompt, the reference images and the duration before you POST, because the moment you have an id you have probably bought the clip.

Why Did My Video URL Stop Working?

Because unsigned_urls is a signed upstream address with a lifetime. Ours came back with X-Tos-Expires=86400 in the query string, which is 24 hours, and the docs describe the field as temporary and expiring in about 24 hours.

There is a second field, mirror_urls, described as persistent and preferred, present when the provider has CDN mirroring enabled. On every Seedance response we pulled today the completed body had exactly these keys:

created_at, id, model, prompt, status, unsigned_urls, updated_at, usage

No mirror_urls. So on this model family, "prefer mirror_urls" resolves to "there is only one URL and it expires". Download the bytes in the same worker that observed completed and put them in your own storage. Do not persist the URL to a database and call the job done, which is how a content pipeline ends up with a table of dead links a day later.

While you are there, read usage:

"usage": {"video_seconds": 5, "video_cost": "0.1000000000"}

video_cost is a string, not a number, and deliberately so: it is documented as a fixed-point 10-decimal string to avoid precision loss. Parse it as a decimal, not a float, and bill from video_seconds rather than from the duration you asked for, because a 5-second request comes back as a 5.04-second file.

How Do You Write One Polling Loop for Every Video Model?

The loop above is about 15 lines, and the reason it is worth writing carefully once is that every video vendor has invented its own version of it. One returns a job object and a separate results endpoint, one wants you to poll a URL from a header, one has a status enum with a different set of names, and one bills for the cancel you thought worked. Supporting three video models natively means three loops, three sets of terminal states and three billing edge cases, none of which is interesting work.

The clips in this post all came back through the same POST /v1/videos and the same GET /v1/videos/{id} regardless of which model generated them, which is why the wait-time table can put Seedance 2.5 and 2.0 Mini in the same column. That normalisation is what a video gateway is for; ofox's video endpoint is the one we run on, and the property to check on any of them is that the status enum and the usage shape stay identical when you change the model field. If they do not, you still have three loops, just hidden behind one hostname.

For picking the model that goes in the loop, our guide to choosing a video generation API by use case covers the quality and price axes, and the fal against Replicate against ofox pricing comparison has the per-second numbers.

Should You Use a Webhook Instead?

If you have a public HTTPS endpoint, yes. Pass callback_url at creation and one POST arrives per task when it settles, carrying the full task object, an X-Ofox-Signature HMAC-SHA256 header and an X-Ofox-Idempotency-Key. The events map one-to-one onto the terminal states.

The validation happens at submit time, not at delivery time. We sent a private-network HTTP address and got this back immediately:

400 invalid_callback_url
"callback_url must be a public HTTPS URL: ssrf blocked: target is private,
 reserved, or scheme not allowed: scheme must be https"

That is worth knowing during development, because the natural thing to try, a localhost or LAN address, is exactly what the SSRF check rejects. Use a tunnel with a real HTTPS hostname, or poll while developing and switch to webhooks in production. Belt and braces is fine too: register the webhook and keep a slow sweeper that polls anything still open after ten minutes, since a webhook you never received is indistinguishable from a job that never finished.

References

Frequently Asked Questions

What does POST /v1/videos return?

HTTP 202 with three fields and nothing else: id, status set to queued, and polling_url. Our submit call took 0.82 seconds. There is no video, no progress figure and no estimated completion in that response, which is the point of a 202: the work has been accepted, not done.

How long does a video generation job take?

Longer than you expect and less predictably. Eight identical 5-second 480p jobs on Seedance 2.0 Mini, all on the same afternoon through the same key, finished between 83.3 and 253.2 seconds, a 3x spread with a median of 104.6. Design the timeout for the tail, not the median.

How often should you poll a video generation job?

Once every 2 to 5 seconds is plenty. The endpoint is rate-limited per API key at 5 requests per second with a burst of 20, and the docs ask you to poll no faster than once per second. Over the limit you get 429 rate_limited with a Retry-After: 1 header. Creating and cancelling are not subject to that limit.

Which video job statuses are terminal?

Four: completed, failed, cancelled and expired. The full state machine has seven states, with pending, queued and in_progress as the non-terminal ones. A polling loop that only breaks on completed and failed will spin forever on a job that was cancelled or expired.

Can I cancel a running video generation job?

Often not. Our DELETE on a job that had been running for six seconds returned 400 cancel_failed, wrapping an upstream 409 saying the task cannot be deleted because it is currently running. Cancellation depends on whether the upstream provider supports interruption, and the gateway refuses to fake a local cancel while the upstream keeps generating and billing.

Why did my generated video URL stop working?

Because unsigned_urls is a temporary signed upstream address. The one we got back carried X-Tos-Expires=86400 in its query string, so it dies 24 hours after signing. Download the file, or use mirror_urls when the provider has CDN mirroring enabled. On the Seedance responses we pulled, mirror_urls was absent entirely.

Do failed video jobs cost money?

The usage object is documented as present only when a job completes, and failed jobs we have run returned usage null. A timeout arrives as status failed with error.code set to expired, not as a distinct status.

Should I use a webhook instead of polling?

If you have a public HTTPS endpoint, yes. Pass callback_url at creation and you get one POST per task at its terminal state, with an HMAC-SHA256 signature and an idempotency key header. The URL is validated at creation time: our http:// address on a private IP was rejected immediately with 400 invalid_callback_url.

Originally published on ofox.ai/blog.

"Transparent Background Is Not Supported for This Model": 3 Fixes

Owen — Thu, 27 Aug 2026 11:33:47 +0000

The error message is straightforward, and the solution involves a single model swap. The background: "transparent" parameter represents a preview capability available only on specific image model deployments, not all of them. Notably, the model used in OpenAI's official cookbook is not the one supporting this feature.

Error:        400, "Transparent background is not supported for this model."
Type:         image_generation_user_error
Fires on:     openai/gpt-image-2  (1.1s, before any generation)
Works on:     openai/gpt-image-1.5  (200, RGBA PNG, 67.3% alpha-zero pixels)
Silent fail:  gemini-3-pro-image, qwen-image-3.0, mai-image-2.5-flash
              all 200, all colour type 2, no alpha channel
Format rule:  PNG only. jpeg is a 400, webp is a 400.
Prompt rule:  prompt beats parameter. Scene words put the scene back.
Measured:     2026-08-24, POST /v1/images/generations, 1024x1024, n=1

Three Fixes in Priority Order

Switch the model. The transparency capability is tied to the specific deployment, not the request parameters. Switching to a different model ID yields a 200 response with genuine alpha channel support.
Maintain PNG output format. Both jpeg and webp formats return 400 errors, but for different reasons. JPEG cannot store alpha channels, while WebP is not supported by this endpoint at all.
Rewrite the prompt. The prompt text carries more weight than the parameter setting. Prompts mentioning scenes, backgrounds, or specific environments result in opaque backgrounds despite the transparency parameter.

Last updated 2026-08-24. OpenAI describes transparent assets as preview functionality, so model capability availability may change. Re-test before relying on any model list.

Why Does gpt-image-2 Say Transparent Background Is Not Supported?

The deployment serving that model ID does not have the transparency preview feature enabled. The error message reflects an actual capability limitation, not a parameter syntax issue.

Complete error response:

{
  "error": {
    "code": null,
    "message": "Transparent background is not supported for this model.",
    "param": null,
    "type": "image_generation_user_error"
  }
}

Two critical details eliminate common explanations. The error arrives within 1.1 seconds—far too quickly for image generation and rejection. Additionally, the identical request with background: "opaque" returns 200 with a normal image on the same model using the same API key. This proves the parameter is reaching the provider and only the transparent value is rejected.

The widespread confusion stems from OpenAI's cookbook example being written against gpt-image-2. The documentation does mention requiring access to a transparency-capable image model, but many users miss this distinction between model name and actual feature availability.

Which Image Models Return Transparent PNGs?

Only one of five tested models successfully returned a transparent PNG.

Model	HTTP	Latency	PNG Colour Type	Transparent Pixels
`openai/gpt-image-1.5`	200	29.0s	6, truecolour + alpha	67.3%
`openai/gpt-image-2`	400	1.1s	n/a	n/a
`google/gemini-3-pro-image`	200	25.8s	2, no alpha	0
`bailian/qwen-image-3.0`	200	49.7s	2, no alpha	0
`microsoft/mai-image-2.5-flash`	200	15.4s	2, no alpha	0

The bottom three rows represent dangerous scenarios. A 400 error provides immediate feedback about what needs changing. A 200 response returning an opaque PNG silently passes validation checks, consumes generation credits, and appears as a white box in presentations days later.

Testing confirmed the behavior directly rather than inferring it. Sending background: "bogus" to gpt-image-1.5 returns a 400 error listing valid values:

Invalid value: 'bogus'. Supported values are: 'transparent', 'opaque', and 'auto'.

Sending identical invalid input to gemini-3-pro-image returns 200 with an image. A validating endpoint rejects garbage input; one accepting garbage was never going to honor transparent either.

Fix 1: Which Model to Switch To

Use openai/gpt-image-1.5—nothing else in the request requires modification. The body that fails on gpt-image-2 works unchanged:

from openai import OpenAI

client = OpenAI(base_url="https://api.ofox.ai/v1", api_key="YOUR_OFOX_API_KEY")

resp = client.images.generate(
    model="openai/gpt-image-1.5",   # gpt-image-2 returns 400 here
    prompt=(
        "A single glossy red ceramic coffee mug, isolated product cutout, "
        "no backdrop, no scene, no shadow, no reflection, transparent background, "
        "no text, no letters, no logos, no watermarks"
    ),
    size="1024x1024",
    background="transparent",
)

For catalog pipelines, explicitly specify the model ID and fail loudly when responses lack alpha channels rather than allowing fallback models to generate thousands of opaque cutouts silently.

Fix 2: Which Output Formats Support Alpha

Only PNG supports alpha channels on this endpoint. JPEG and WebP both return 400 errors:

output_format: "jpeg"  ->  400  Transparent background is not supported for JPEG output format
output_format: "webp"  ->  400  Invalid value: 'webp'. Supported values are: 'png' and 'jpeg'.

These represent different failure modes. The JPEG rejection reflects the format's inherent limitation—it cannot store transparency. The WebP rejection indicates this endpoint simply does not offer that format. For production pipelines, generate PNG files and convert downstream rather than requesting WebP directly.

Fix 3: Why Is Transparent Image Still Full of Background

The prompt parameter outweighs the API setting by a substantial margin. OpenAI's documentation mentions this; testing quantified the impact.

With identical model and background: "transparent" settings, two different prompts produced vastly different results:

Prompt	Fully Transparent Pixels	Fully Opaque Pixels	Result
Isolated subject, "no backdrop, no scene, no shadow"	67.3%	24.1%	Clean cutout
"on a marble kitchen counter at sunrise, soft window light"	43.5%	21.7%	Mug, counter, window frame, sunrise sky knocked out

The second image is not a feature failure—the transparency system worked as designed. It produced alpha around the scene explicitly requested in the prompt text, which proves useless for product catalogs and worse if unreviewed files enter production.

Practical guidance: describe only the object, then add negative constraints. Words like "counter," "studio," "gradient," "table," "sunset," and "shadow" reintroduce backgrounds. Reflections have the same effect.

How to Check PNG Transparency

Read a single byte. PNG stores colour type in the IHDR chunk at offset 25 in the file:

python3 -c "print('colour type', open('out.png','rb').read(26)[25])"
# 6 = truecolour + alpha   4 = greyscale + alpha
# 2 = truecolour, no alpha 3 = indexed (transparency may live in a tRNS chunk)

Colour type is necessary but insufficient. An RGBA file with alpha channel values of 255 everywhere is technically opaque despite having an alpha channel. Count pixels instead:

from PIL import Image

im = Image.open("out.png")
print(im.mode)                                     # RGBA if an alpha channel exists
if im.mode == "RGBA":
    hist = im.getchannel("A").histogram()
    px = im.width * im.height
    print(f"{100 * hist[0] / px:.1f}% fully transparent")
    print(f"{100 * hist[255] / px:.1f}% fully opaque")

Every statistic in this article came from these two checks. Include alpha validation in CI pipelines. When a generation service silently switches which deployment backs a model ID, it will not announce the change; a test asserting "more than 30% of pixels are fully transparent" will catch it.

How to Test Multiple Image Models Without Multiple Accounts

The genuine difficulty is not the code—it is accessing five different vendor accounts, SDKs, and billing relationships simultaneously just to answer one yes-or-no question about a parameter.

All models in the comparison table respond to the same POST /v1/images/generations endpoint using the same API key because they are exposed through the OpenAI-compatible interface. The matrix exists because changing model= was the complete difference between rows. The tests ran through ofox, and any gateway that passes the field through rather than normalizing it will produce identical results. Verify this passthrough before trusting results: if background: "bogus" does not return 400, the route is not truthfully reporting the parameter state.

What If Your Required Model Lacks Transparency

When locked to a model that drops the field, three options exist: two honest approaches and one to avoid.

Generate on solid background and cut it out. A flat, unnatural background color absent from the subject makes downstream matting far simpler. Slower and lossy at edges, but predictable.
Generate once on a capable model and reuse. Transparency is a file property, not pipeline-dependent. One quality cutout beats repeated re-renders.
Do not ship the opaque 200 response. Unreviewed opaque images surface as white rectangles on colored slides, and by then the batch reaches thousands of files.

What Does One Transparent Image Cost

A successful 1024x1024 generation on gpt-image-1.5 billed 46 input tokens and 4,415 output tokens (4,160 image, 255 text). At published rates—$5 per million input, $32 per million output image, $10 per million output text—the cost is approximately $0.136 per cutout image.

One caveat: gpt-image-2 with background: "opaque" reported only 196 image output tokens for the same size. Different models reporting wildly different token counts per megapixel means pricing should derive from measured usage per model rather than assuming constant rates. The same principle applies to text models.

Frequently Asked Questions

Why does gpt-image-2 say transparent background is not supported?

Transparent image assets represent a preview feature gated per model deployment. The tested gpt-image-2 route lacks this capability. The same request with background: "opaque" or "auto" returns 200 on the same model, proving the parameter reaches the provider. Only the transparent value faces rejection in approximately 1.1 seconds—impossibly fast for post-generation rejection.

Which OpenAI image model supports background transparent?

On the tested route, openai/gpt-image-1.5 returns PNG with IHDR colour type 6 and 67.3% transparent pixels. OpenAI's cookbook uses gpt-image-2, explaining user surprise. The documentation states you need access to a transparency-capable model—access determines capability, not model name alone.

Can I get a transparent JPEG?

No. JPEG lacks alpha channel support, and the API rejects this combination up front with the error message. PNG remains the only option; output_format: "webp" returns an error stating that format is unsupported.

My call returned 200 but the PNG has white background. What happened?

The model likely never received the parameter. Three non-OpenAI image models tested with background: "transparent" all returned 200 with colour type 2 PNGs lacking alpha. One also accepted background: "bogus" and returned 200—the telltale sign a route drops the field entirely rather than validating it.

Why is there still background in my transparent image?

Prompt text outranks the parameter setting. Testing demonstrated the same model and background setting produced 67.3% transparent pixels with an isolated-subject prompt versus 43.5% with scene descriptions. Describe only the subject and specify "no backdrop, no scene, no shadow" in negatives.

How do I check PNG transparency really exists?

Read byte 25: 6 means truecolour with alpha, 2 means no alpha. Colour type 3 (indexed) may carry transparency in a separate chunk, treat as uncertain. Then count pixels at alpha zero, since an RGBA file with alpha entirely 255 is opaque despite having a channel.

Does an image gateway strip the background parameter?

Not on the tested route. gpt-image-2 accepted background: "opaque" and "auto" with 200 and rejected only transparent; gpt-image-1.5 rejected invalid value "bogus" with a 400 listing legal options. Both behaviors require the field reaching the provider.

How much does one transparent image cost?

A 1024x1024 transparent generation on gpt-image-1.5 billed 46 input and 4,415 output tokens (4,160 image). At published rates, approximately $0.136 per image.

Originally published on ofox.ai/blog.

Seedance 2.5 Image-to-Video: First and Last Frame Control (2026)

Owen — Wed, 26 Aug 2026 04:35:20 +0000

Seedance 2.5 treats the last frame as a destination, not a hint. Give it both ends of a shot and it arrives at the one you asked for, which is the thing 2.0 Mini would not do.

Endpoint: POST /v1/videos → 202 + polling_url
Field: frame_images[] with frame_type first_frame / last_frame
Ratio rule: aspect_ratio is a 400 on 2.5 frame jobs. Omit it, or send adaptive.
Same on 2.0: no. 2.0-mini accepts aspect_ratio with frames.
Closing frame error (0-255 mean absolute difference, lower is closer):
- Seedance 2.5 at 720p: 2.0
- Seedance 2.5 at 480p: 5.4
- Seedance 2.0 Mini: 35.9
- Two unrelated images: 39.0 (the ceiling)
Billed: $0.11/s at 480p, $0.24/s at 720p, at the text-to-video row
Measured: 2026-08-24, one 5s clip per configuration

How Do You Send a First and Last Frame to Seedance 2.5?

Two elements in frame_images, each tagged with a frame_type. There is no mode switch; the endpoint infers image-to-video from the body.

import base64, json, requests

def data_uri(path):
    return "data:image/jpeg;base64," + base64.b64encode(open(path, "rb").read()).decode()

body = {
    "model": "bytedance/seedance-2.5",
    "prompt": "The woman stops walking on the rain-slicked street, turns toward the "
              "camera, and the shot pushes in to her face. Hand-painted 2D animation style.",
    "duration": 5,
    "resolution": "480p",
    # no aspect_ratio here on purpose: see the next section
    "frame_images": [
        {"type": "image_url", "image_url": {"url": data_uri("wide.jpg")},  "frame_type": "first_frame"},
        {"type": "image_url", "image_url": {"url": data_uri("close.jpg")}, "frame_type": "last_frame"},
    ],
}

r = requests.post("https://api.ofox.ai/v1/videos", json=body,
                  headers={"Authorization": "Bearer YOUR_OFOX_API_KEY"})
print(r.status_code, r.json())   # 202 {'id': ..., 'status': 'queued', 'polling_url': ...}

Data URIs work, which matters more than it sounds: it means you can test first-last-frame generation without standing up a public image host first. Then poll polling_url until the status is terminal, which is its own set of traps worth reading before you write the loop.

The prompt still does work here. It is not decoration between two fixed images: it decides what happens on the way, and how many camera moves get spent doing it.

Does Seedance 2.5 Actually Land on the Last Frame?

Yes, and the gap against 2.0 Mini is not subtle. Same two images, same prompt, same duration, same day.

To put a number on it, we pulled frame 0 and the final frame out of each clip, resized both the frame and the source image to 256x144, and took the mean absolute per-channel difference on a 0 to 255 scale. Low is close.

Run	Opening frame error	Closing frame error	Billed
Seedance 2.5, 720p	1.8	2.0	$1.20
Seedance 2.5, 1080p	1.8	3.1	$2.40
Seedance 2.5, 480p	3.0	5.4	$0.55
Seedance 2.0 Mini, 480p	9.5	35.9	$0.10
Seedance 2.0 Mini, 480p, no ratio field	9.6	37.1	$0.10
Reference: two unrelated images	38.6	39.0	n/a

Read the bottom row first. Two images that have nothing to do with each other score about 39. Mini's closing frame scores 35.9, which is to say it ended somewhere of its own choosing: same rainy palette, different character, different framing. The opening frame is a different story, and both models hold it tightly, which fits the older behaviour we saw on the 2.0 line where the first frame is honoured and the last frame drifts.

Two caveats before you build on this. Each configuration is one run, not a distribution, so treat the ordering as the finding and the exact decimals as one sample. And the difference metric is deliberately crude: it will punish a correct composition that is two frames early. That crudeness is also why the 35.9 is convincing. Nothing that mild could produce a number that close to unrelated.

Why Does aspect_ratio Return 400 on a 2.5 Frame Job?

Because the ratio is derived from the first-frame image, so sending it is an error rather than a redundancy.

POST /v1/videos  {model: bytedance/seedance-2.5, resolution: 480p,
                  aspect_ratio: "16:9", frame_images: [first, last]}

400 invalid_request
"The parameter ratio specified in the request is not valid. For first-frame or
 first-last-frame generation, the output ratio follows the first-frame image."

The part that catches people: our first-frame image is exactly 1280x720, so the 16:9 we sent was correct. It is still refused. The API is not comparing your value against the image, it is refusing to accept a value at all in this mode.

Three things follow, and all three are measured rather than assumed:

Request	Result
2.5 + `frame_images` + `aspect_ratio: "16:9"`	400, ratio not valid
2.5 + `frame_images` + `aspect_ratio: "adaptive"`	202, output 854x480
2.5 + `frame_images`, field omitted	202, output 1280x720 at 720p
2.5 text-to-video + `aspect_ratio: "16:9"`, no frames	202
2.0 Mini + `frame_images` + `aspect_ratio: "16:9"`	202, output 864x496

So the restriction belongs to 2.5's frame-based tasks specifically. It is not a rule about video generation, it is not a rule about the whole model, and it is not a rule about the gateway. Code that has worked for months against Seedance 2.0 will start returning 400 on the day someone edits the model ID to 2.5, and the error message will talk about a parameter nobody changed. ByteDance documents this directly. The Seedance 2.5 prompt guide splits tasks into locked and unlocked, puts "Editing, first and last frames, and extension" in the locked group, and describes locked as "the output video's aspect ratio, and in some cases its duration, are locked". The same page adds the line that explains our 2.0 result: "Seedance 2.0 does not make this distinction."

What Else Does the frame_images Validator Reject?

Four shapes, all caught before the request goes upstream. Each came back in roughly a second and cost nothing.

What you send	HTTP	Message
Two elements both `first_frame`	400	`frame_images: at most one first_frame and one last_frame`
Only a `last_frame`	400	`frame_images: last_frame requires a first_frame`
`frame_type: "start_frame"`	400	`frame_images[0]: frame_type must be first_frame or last_frame`
`frame_images` and `input_references` together	400	`frame_images and input_references are mutually exclusive`

Notice the indexed path in the third one. When you are generating request bodies in a loop, frame_images[0] tells you which element to look at, which is more than most video APIs give you.

The second rule is the one worth designing around. There is no last-frame-only mode, so a pipeline that wants to end on a known image has to also decide where it starts. If you only care about the ending, generate a plausible opening still first and pass both.

What Does an Image-to-Video Clip Actually Cost?

It bills at the text-to-video row for that resolution. The model page prices Seedance 2.5 by resolution and mode, and there is no image-to-video row, so the natural fear is that you land on the "all other combinations" line at $0.568/s. You do not.

Resolution	Model page, text-to-video	Our 5s frame job billed	Implied
480p	$0.11/s	$0.55	$0.11/s
720p	$0.24/s	$1.20	$0.24/s
1080p	$0.48/s	$2.40	$0.48/s

Three resolutions, three exact matches. The files came back at 854x480, 1280x720 and 1920x1080, all 24 fps with an AAC track at 32 kHz. Duration lands at 5.04s rather than exactly 5, so bill on the usage.video_seconds field rather than on your own arithmetic.

For comparison, the same request on bytedance/seedance-2.0-mini at 480p billed $0.10 for the clip, which is why Mini stays the right tool for throughput work where nobody is checking the closing frame. It is five and a half times cheaper and, on this task, the difference shows.

Which Resolutions Does Seedance 2.5 Accept?

Ask the pricing table, not the description. The model page currently prints a prose summary saying 480p or 720p, while the pricing table on the same page lists 1080p rows for text-to-video and video-to-video, and a 1080p first-last-frame job ran to completion.

That kind of disagreement is normal in the weeks after a resolution tier opens, and the resolution field is the cheapest possible thing to test: send the request, read the status code. A rejection is instant and free.

Source	Says
Model page prose	480p or 720p, 720p by default
Model page pricing table	480p, 720p, 1080p rows, 1080p at $0.48/s text-to-video
Live API, first-last-frame at 1080p	Accepted, finished in 176.2s, billed $2.40

One thing changes at 1080p that nothing on the page mentions: the file came back as HEVC, where the 480p and 720p outputs were H.264. If you concatenate clips with stream copy, or serve them straight to a browser, a mixed-codec batch will bite. Check the codec on the file rather than assuming it from the model.

Duration is the other axis that changed between generations: 2.5 takes 4 to 30 seconds where the 2.0 line stops at 15, and a 30-second clip needs roughly ten beats of action in the prompt or the model will stretch one moment across ten seconds. We covered that pacing problem in the 2.5 prompting guide, and the 2.5 against 2.0 comparison has the rest of the capability deltas.

How Do You Compare Two Video Models Without Two Consoles?

The comparison in this post required exactly one thing that is annoying to arrange: running the same body against seedance-2.5 and seedance-2.0-mini with nothing else changed. Two model IDs, one key, one endpoint shape. Done natively, that is two provider consoles, two credit balances and two request schemas, at which point most people compare one model against their memory of another one and call it a benchmark.

Both models here answer on the same POST /v1/videos because the video endpoint is model-agnostic; the diff between the two runs in this article was the model field and nothing else. We used ofox's video endpoint for it, and the same trick works on any gateway that keeps the request shape stable across vendors. The thing to check before trusting a cross-model comparison is that the gateway is not normalising fields on the way through: if aspect_ratio behaved identically on 2.5 and 2.0, that would be the smell. It did not, which is the evidence the field is reaching each model untouched.

References

Frequently Asked Questions

How do I send a first and last frame to Seedance 2.5?

Put both images in the frame_images array on POST /v1/videos, each element carrying an image_url and a frame_type of first_frame or last_frame. The mode is inferred from the body, so there is no mode parameter to set. Images can be public URLs or data URIs; base64 data URIs work, which saves standing up an image host for a test.

Does Seedance 2.5 actually land on the last frame you give it?

Yes, closely. We compared the closing frame of the output against the requested last frame and got a mean absolute pixel error of 5.4 at 480p and 2.0 at 720p, on a 0 to 255 scale. The same request on Seedance 2.0 Mini scored 35.9, against a 39.0 baseline for two unrelated images. On Mini the last frame reads as a suggestion; on 2.5 it is a target.

Why does aspect_ratio return 400 on a Seedance 2.5 first-last-frame job?

Because the output ratio is taken from the first-frame image, so the field is refused rather than ignored. The error reads "The parameter ratio specified in the request is not valid. For first-frame or first-last-frame generation, the output ratio follows the first-frame image." It fires even when the ratio you send matches the image exactly. Omit aspect_ratio, or send adaptive.

Does the same aspect_ratio rule apply to Seedance 2.0?

No. The identical body with frame_images and aspect_ratio 16:9 was accepted on bytedance/seedance-2.0-mini and returned an 864x496 clip. The restriction is specific to 2.5's locked task types, not to frame-based generation in general, which is why code that works on 2.0 breaks the day you switch the model ID.

Can I send only a last frame?

No. It returns 400 with "frame_images: last_frame requires a first_frame". You also cannot send two first frames: that is 400 with "at most one first_frame and one last_frame". Both of those are validated before the request goes upstream, so they cost nothing and come back in about a second.

How much does a Seedance 2.5 image-to-video clip cost?

It bills at the text-to-video rate for that resolution, not at the 'all other combinations' row. Our 5-second 480p job billed $0.55 and the 720p job billed $1.20, which is exactly $0.11/s and $0.24/s from the model page. Failed jobs return usage null and are not billed.

Does Seedance 2.5 support 1080p?

The pricing table on the model page lists 1080p rows for both text-to-video and video-to-video, and our 1080p first-last-frame job completed in 176.2 seconds and billed $2.40, which is the $0.48/s text-to-video rate. The prose description on the same page still says 480p or 720p. Trust the pricing table and a live request over the description.

Does the output have audio?

Yes, by default. Every clip we pulled back carried an AAC track at 32 kHz alongside H.264 video at 24 fps. If you are stitching clips later, that matters: the audio streams have to match too, or ffmpeg concat with stream copy will refuse.

Originally published on ofox.ai/blog.

AI Video API Cost in 2026: List Price vs Usable-Clip Cost

Owen — Wed, 26 Aug 2026 00:34:49 +0000

Nobody overspends on video generation because they picked the wrong rate card. They overspend because they budgeted for the clips they wanted and paid for the clips they threw away. The per-second rate is the term everyone compares and the smallest term in the bill. The term that actually moved in 2026 is how many generations it takes to get one shot you can cut into a timeline, and that number roughly tripled without a single price change.

The formula:  effective cost = list rate x seconds x attempts per usable clip
What moved:   attempts per keeper went 2-3 -> 7-8 during 2026 congestion (36kr, 2026-04-01)
What did not: the rate card
Measured:     6s 480p Seedance 2.5 billed $0.66 in 103s; 30s billed $3.30 in 200s
Delivered:    that same 6s clip is $1.32 at 2 attempts and $5.28 at 8
Expiring:     the 1080p launch discount ends 2026-09-17 on every gateway that mirrored it
Snapshot:     2026-08-25

Everything below is either a rate card we read on 2026-08-25, a generation we ran and were billed for, or reporting we cite by name. Where the number people repeat does not survive a check, we say so rather than repeating it.

Why Is the Rate Card the Wrong Number?

Because it prices generations, and you ship keepers.

Every video API bills per output second of whatever comes back, including the takes you delete. So the unit that matters is not the per-second rate but the per-second rate multiplied by your reject ratio:

effective_cost_per_delivered_second = list_rate x (generations / accepted)

That second factor is the one nobody puts in a pricing comparison, because no vendor can quote it. It depends on the model, your prompt discipline, how specific your brief is, and, uncomfortably, on how busy the provider is that week.

Here is what that does to a real bill. We generated a 6-second 480p clip on Seedance 2.5 on 2026-08-13 and were billed $0.66:

Attempts per keeper	Cost per delivered 6s clip	Cost per delivered minute
1 (never happens)	$0.66	$6.60
2	$1.32	$13.20
3	$1.98	$19.80
5	$3.30	$33.00
8	$5.28	$52.80

The spread between the top and bottom of that table is 8x. The spread between the cheapest and most expensive rate card on the market for the same model is under 3x. If you are optimising the rate card while ignoring the attempt count, you are tuning the smaller dial.

What Actually Changed in 2026?

The attempt count, and it changed for reasons outside your pipeline.

This is the part with real reporting behind it. In April, 36kr documented what Seedance users were seeing: where creators had previously generated two or three clips and picked one usable take, they were now often generating seven or eight to find one. Same prompts, same model name, roughly triple the burn.

The surrounding conditions were not subtle. That same reporting describes queue numbers reaching into six figures. 21jingji reported queue positions climbing from 1,900 to 50,000 and waits stretching to 68 hours, alongside capacity management that Chinese coverage named 降智, roughly "dumbing down": throttling output quality on some task types to clear the backlog. Consumer-side pricing moved at the same time, with early-adopter discounts withdrawn and the cost of a 15-second generation for paying members rising about 167%.

You do not have to accept any editorial framing to use this. The operational lesson stands on its own: your provider's capacity state is an input to your unit economics, and it is not on the rate card. A quarter where attempts per keeper drifts from 3 to 6 doubles your content cost while your finance dashboard shows a flat price per second.

That is also why a cost model with a single hardcoded multiplier is worthless. Instrument the ratio and recompute it weekly.

What Do the Rate Cards Actually Say?

Read on 2026-08-25, for the same model, so the comparison is real.

Route	480p	720p	1080p	Notes
Gateway (ofox)	$0.11/s	$0.24/s	$0.48/s	1080p is 20% off a $0.60 list, promo ends 2026-09-17
Runway API	$0.20/s	$0.30/s	not listed	20 and 30 credits/s, plus a surcharge per input-video second
Higgsfield	3 cr/s	6.5 cr/s	not listed	gated to the $49 Plus plan and above
BytePlus ModelArk	billed per token, $10.70 / M tokens	—	—	official international console
Volcano Engine Ark	approx CNY 1.51/s at 720P	—	—	China console, 1080P at 72% of list to 2026-09-17

Four things in that table are worth more than the cheapest cell.

The first is that the same model is not the same product on every route. ModelArk and Volcano Engine Ark are separate consoles with separate model IDs, dreamina-seedance-2-5-260628 internationally and doubao-seedance-2.5 in China, and you cannot mix credentials or IDs between them.

The second is that credit pricing is rate pricing wearing a costume. Runway's API credit is one cent, so 30 credits per second is thirty cents per second, before the surcharge it adds for each second of input video you supply. Higgsfield's credits only convert through a subscription, which means its effective rate depends on how much of your monthly allowance you actually burn. A plan you use at 40% is a rate card 2.5x worse than the one advertised.

The third is that token billing and per-second billing answer different questions. ByteDance bills its own API per token, which is honest to how the model works and useless for forecasting a 25-shot episode until you have run the token formula against real prompts. Per-second gateway pricing is a markup on that, bought for predictability.

The fourth is the one with a date attached, and it is below.

What Did We Actually Get Billed?

Three runs on 2026-08-13, and the numbers are less flattering than the rate card implies.

Run	Model	Billed	Wall clock	Note
6s, 480p	Seedance 2.5	$0.66	103 s	audio track included
30s, 480p	Seedance 2.5	$3.30	200 s	returned 30.08 s
6s, 480p	Seedance 2.0	$0.378	289 s	same prompt, same second
6s, 1080p	Seedance 2.5	$0.00	—	HTTP 400, resolution rejected

The last row is the good news and it is worth building for. When Seedance 2.5 was still capped at 720p, a 1080p request returned resolution 1080p not supported; allowed: [480p 720p] rather than quietly downscaling and billing you. A synchronous 400 costs nothing. Any parameter you can get rejected at submit time is a parameter that cannot become a wasted generation, so validate aggressively and prefer providers that fail loudly.

The 2.0 versus 2.5 pair is the sharper lesson. Seedance 2.0 bills 36% less per second at 480p and took 2.8x longer to return. If 2.0 also needs one extra attempt on your shot list, its price advantage is gone and you have paid for the privilege in latency. We wrote up where each model still wins in Seedance 2.5 vs 2.0.

How Do You Actually Cut the Bill?

Attack attempts. The rate card has maybe 30% of movement in it; the attempt count has 400%.

Four levers, in the order we would apply them to an existing pipeline.

Draft cheap, deliver expensive. At $0.11 against $0.48, 480p costs less than a quarter of 1080p on the same model. Iterate the composition, the beats and the camera at 480p, then re-render only the approved shot at delivery resolution. A 25-shot episode that iterates four times at 480p and renders once at 1080p costs meaningfully less than one that iterates twice at 1080p, and it is the same finished episode.

Remove the model's freedom to reinterpret. Every degree of freedom you leave open is a coin flip you pay for. Reference assets pin identity and setting; Seedance 2.5 accepts up to 50 of them as 30 images, 10 videos and 10 audio clips. First and last frames pin where a shot starts and ends, and in our first and last frame test the 2.5 last-frame error was 5.4 against 35.9 on 2.0 Mini. Integer-second timestamps pin when beats land. None of these lower the rate. All of them lower how often you re-roll.

Get your task type right the first time. On Seedance 2.5 the task is inferred from words in your prompt, so an edit request without an edit trigger word is classified as a reference-to-video job and returns a brand new clip. It is a perfectly good clip. It is also a full billed generation that answered a question you did not ask. Setting the task type explicitly moves that failure to submit time, where it is free. The trigger words and the failure modes are in how to use Seedance 2.5.

Measure the ratio, not the average. Log billed amount and generation count per accepted shot, not per request. A per-request average tells you the rate card, which you already knew. Cost per accepted shot tells you when your provider's capacity state has quietly moved, usually two weeks before anyone notices in the finance review. If you are polling asynchronously, the same log gives you queue behaviour for free; we broke that pattern down in video generation API polling.

What Expires on 2026-09-17?

The 1080p price, everywhere.

Seedance 2.5 shipped without 1080p and gained it on 2026-08-17 Beijing time. ByteDance attached a launch discount running to 2026-09-17, and the gateways mirrored it at various depths: 20% off at ofox and Atlas Cloud, 28% off at EvoLink, 72% of list on Volcano Engine Ark. Different numbers, one shared expiry date.

If you are building a cost model this month, carry both the promotional and the post-promotional 1080p rate, because a spreadsheet anchored on $0.48 per second silently becomes wrong on September 17th and nothing in your pipeline will tell you. On a 25-shot, 60-second episode delivered at 1080p, the difference between $0.48 and $0.60 per second is $7.20 per episode before attempts, and $28.80 to $57.60 after a realistic multiplier. At 1,000 episodes that is a budget line, not a rounding error.

Three Numbers We Could Not Verify

Cost claims travel further than their sources, and this topic has three in wide circulation that we could not stand behind, so we are not repeating them as facts.

A widely quoted V2EX post said to be titled along the lines of "it's not the model, it's your budget" does not appear to exist under that title. The closest real thread, a June discussion of pricing, failure and waiting, argues that unpredictable pricing hurts more than model quality does, which is a fair point, but it contains no cost figures at all. The commonly repeated per-clip and per-ad figures attached to it have no traceable origin.

A per-episode figure of roughly $7.6 for a 60-second, 25-shot production is often attributed to Tencent Cloud. Tencent Cloud's own pipeline write-ups publish cost reduction percentages and per-task unit costs, such as storyboard splitting at CNY 2.8 against CNY 9, and production timings of about three hours per 2-3 minute episode. They do not publish a total per-episode cost. The $7.6 may be someone's arithmetic; it is not a vendor figure.

And the queue number frequently cited as 80,000 is not what the reporting says. 36kr describes queue numbers reaching around 100,000; 21jingji describes a rise from 1,900 to 50,000. Both are worse than 80,000 in different ways, and neither is 80,000.

If you are building a business case on any of these, build it on your own logs instead. The one number that matters is one only your pipeline can produce.

The Short Version

The rate card is a starting point that vendors compete on and a term you have almost no leverage over. Attempts per usable clip is the term that moved 3x in 2026, that varies with your provider's capacity state, that responds to reference assets and explicit task types and resolution laddering, and that nobody will quote you.

Price it, log it, and recompute it weekly. Then compare rate cards, with the multiplier already in the sheet.

Frequently Asked Questions

How much does an AI video generation API actually cost per second?

List rates for Seedance 2.5 on a gateway run $0.11 per output second at 480p, $0.24 at 720p, and $0.48 at 1080p during the launch discount window. Runway's API bills the same model at 20 credits per second at 480p and 30 at 720p, which is $0.20 and $0.30 at the API's one-cent credit. Those are the numbers on the rate card. What you actually pay per clip you can ship is that rate multiplied by how many generations you burn to get one keeper, which in 2026 has been anywhere from 2 to 8.

What is the effective cost of an AI video clip?

Effective cost is the list rate times the number of generations per usable output. A 6-second 480p Seedance 2.5 clip billed us $0.66. At the 2-3 attempts per keeper creators reported before the 2026 congestion, that clip costs $1.32 to $1.98 delivered. At the 7-8 attempts 36kr reported during the worst of it, the same clip costs $4.62 to $5.28. The rate card did not move. The bill tripled.

Why do I need so many generations to get one usable clip?

Three causes, and only one of them is your prompt. Capacity throttling degrades output quality during congestion, which Chinese coverage in 2026 labelled 降智. Underspecified prompts leave the model free to choose, and it chooses differently every seed. And ambiguous task typing sends an edit request down a reference-to-video path, so you get a technically fine clip that answers the wrong question. The second and third are fixable in your pipeline. The first is not.

Is a cheaper per-second model actually cheaper?

Only if its attempt count holds. Seedance 2.0 at 480p bills $0.07 per second against $0.11 for 2.5, so 2.0 looks 36% cheaper. If 2.0 needs four attempts for a shot that 2.5 lands in two, 2.0 costs more per delivered second and takes longer. We measured 289 seconds of wall clock on 2.0 against 103 on 2.5 for the same 6-second prompt, so the slower model also spends more of your pipeline's time.

How do I lower video API costs without changing models?

Cut attempts, not rate. Draft on 480p and only re-render the approved shot at delivery resolution, since 480p is a fifth of the 1080p rate. Pin the parts you are not iterating on with reference assets and first and last frames. Write integer-second beats so the model is not inventing structure. And log the billed amount per accepted shot rather than per request, because a per-request average hides exactly the number you need.

Does the 1080p discount on Seedance 2.5 last?

No. Seedance 2.5 gained 1080p on 2026-08-17 Beijing time, and ByteDance attached a launch discount that runs to 2026-09-17. Gateways mirrored it at varying depth, from 20% off to 28% off. Every one of those prices reverts on the same date, so a cost model built on the promotional 1080p rate breaks in September. Model both numbers now.

Originally published on ofox.ai/blog.