TokenLab Seedance Task Cancellation: Queued Job Billing and Cancellation Checklist

TokenLab supports cancelling queued Seedance video generation tasks before they enter processing, using the same task ID returned at creation. TokenLab prices every Seedance tier on generated output tokens only (input is rated 0.000000 across all six tiers in the live pricing snapshot), so a task cancelled before processing starts has produced no billable output under that structure. That is the strongest evidence-based answer available for "will I be charged," but it is an inference from the pricing model, not a TokenLab-published cancellation billing statement.

This refresh does not include a fabricated cURL example, invented status codes, or a guessed response payload for the cancellation endpoint. No captured request/response evidence for that specific call was available in this evidence pull, and inventing one would be worse than omitting it. A wrong status code or field name in a published article can break someone's retry logic in production. Instead, this article gives you the confirmed billing reasoning, a precise list of what remains unverified, and a verification checklist to run against the live docs before you ship cancellation into a queue.

Key Takeaways

Source Snapshot

Evidence source	What it covers	Observed
TokenLab live model/pricing snapshot	Seedance, Veo, PixVerse, Hailuo rates on TokenLab	2026-07-07
PixVerse Platform Docs	PixVerse V6 per-second credit pricing	2026-07-08
fal PixVerse V6 model page	PixVerse V6 per-second USD pricing, request shape	2026-07-08
Google AI Gemini API pricing	Veo 3.1 per-second pricing, audio-failure billing clause	2026-07-08
MiniMax API video packages	Hailuo point pricing, failure non-deduction clause	2026-07-08
Runway API pricing	seedance2 and Veo 3 credit rates on Runway	2026-07-08
Kling AI Developer Platform pricing	Kling unit pricing (list price, needs live verification)	2026-07-08
TokenLab task cancellation API reference	Endpoint pattern; no request/response payload captured in this evidence pull	not captured in this evidence pull

What's Confirmed vs. What's Inferred

Read this table before you build anything against it.

Question	Status	Basis
Is Seedance billed output-only (input rate 0) on TokenLab?	Confirmed	TokenLab live pricing snapshot, observed 2026-07-07
Does a cancelled queued task (zero output produced) incur a Seedance generation charge?	Inferred, not confirmed	Derived from the output-only pricing structure above; no TokenLab cancellation-billing statement in this evidence set
Are credits refunded for a task cancelled after some cost was already incurred?	Unconfirmed	No TokenLab statement in the evidence reviewed
Is there a separate reservation or hold charge at submission time, independent of output?	Unconfirmed	No TokenLab statement in the evidence reviewed
Do cancelled tasks remain queryable via the standard task status endpoint?	Unconfirmed	No captured sample task object showing a cancelled state in this evidence pull
Exact HTTP status codes for successful or rejected cancellation	Unconfirmed	Not captured in this evidence pull; verify in the live API reference
Exact request/response payload and auth header for the cancellation call	Unconfirmed	Not captured in this evidence pull; this article does not fabricate one

Does Cancelling a Queued Seedance Task Save Cost?

This is the first question a paying API buyer asks before wiring cancellation into a queue, so here is what the pricing evidence actually shows.

TokenLab's live pricing snapshot lists every Seedance tier as per_token with an input rate of 0.000000 and a nonzero output rate. That means the charge is entirely a function of generated output. If a task is cancelled while still queued, before the model has produced any frames, there is no output to price under that structure.

Model	Input rate	Output rate	Unit	Source	Observed
seedance-1.0-pro	0.000000	2.205882	per token	TokenLab live pricing evidence	2026-07-07
seedance-1.0-pro-fast	0.000000	0.617647	per token	TokenLab live pricing evidence	2026-07-07
seedance-1.5-pro	0.000000	1.176471	per token	TokenLab live pricing evidence	2026-07-07
seedance-2.0	0.000000	6.764706	per token	TokenLab live pricing evidence	2026-07-07
seedance-2.0-fast	0.000000	5.441176	per token	TokenLab live pricing evidence	2026-07-07
seedance-2.0-mini	0.000000	3.382353	per token	TokenLab live pricing evidence	2026-07-07

Rates are TokenLab's live per-token index for input and output. Convert to your billed currency using your TokenLab plan and dashboard, since the raw index values are not stated as a currency in this evidence set.

Seedance API Refund for Queued Tasks

What this evidence does not tell us: whether TokenLab places any reservation, hold, or minimum charge at task submission time, independent of output, and whether a refund flow exists at all for tasks that do incur partial cost before cancellation. Neither detail was present in the evidence reviewed here. If your integration cancels large batches routinely, confirm this directly with TokenLab support or the billing docs rather than assuming zero cost by default. The most defensible working assumption from the pricing structure is not "charged then refunded"; it's "a cancelled queued task with zero output never generates a chargeable output-token line item in the first place." That's a subtle but important distinction if you're building a reconciliation report against your invoice.

For comparison, other video providers publish explicit non-deduction language for failed jobs. Google states that for Veo 3.1, users are charged only if video is successfully generated when an audio processing issue prevents generation. MiniMax states that video generation failures or security-review videos do not result in a point deduction on Hailuo packages. Neither statement covers a cancelled queued task specifically, and neither is a TokenLab statement, but they show that "no output, no charge" is a common pattern across the video API market. That supports, without confirming, the same conclusion for TokenLab Seedance.

TokenLab is built for developers who need this kind of pricing behavior spelled out before they build cost-sensitive pipelines. If you're evaluating Seedance, Veo 3, PixVerse V6, Kling, or Hailuo through one API surface, check current model pricing and get an API key before you commit queue architecture around cost assumptions.

How Seedance Task Cancellation Works

Cancellation targets a task resource using the same task ID returned when the job was created. The documented pattern is a delete-style call against the task resource path, using the same API key model as task creation. This evidence set does not include a freshly captured request/response payload, header format, or confirmed status codes for this specific endpoint.

• Queued tasks are the primary cancellable window. If a task has not started processing, cancellation is expected to succeed.
• Processing or terminal tasks (completed, failed, previously cancelled) are expected to reject cancellation. Treat a rejected cancel call as a normal, expected outcome for a task that already moved past the queued state, not a bug to retry in a loop.
• Cancelled tasks are expected to remain queryable through the standard task status endpoint, consistent with completed and failed tasks. This is unconfirmed in this evidence pull (see the table above). Confirm the exact response field name and value (for example, a status field set to cancelled) in the API reference before parsing it in production.
• Cancellation support can vary by task and model combination. Check the task cancellation reference for current coverage before treating cancellation as guaranteed across every Seedance task type.
• For the polling side of this lifecycle, pair this with the async jobs and polling guide rather than building status-check logic from scratch.

Seedance Cancellation API Example: Why It's Not Here

If you searched for a "Seedance cancellation API example," here's the direct answer on why this article doesn't give you one: this evidence pull did not capture the exact endpoint path, authentication header format, request payload, or response body for the cancellation call. A code sample built on guessed status codes or an assumed field name is not more useful than no code sample. It's a production bug waiting to happen, especially around retry logic keyed to specific HTTP codes.

What you get instead is the verification checklist below, built to be run against the live docs in under five minutes, and the confirmed billing reasoning above, which doesn't depend on knowing the exact wire format.

How to Cancel a Seedance Video Job

1. Store the task ID returned at creation time in your job table or session state.
2. Detect the cancellation trigger: bad prompt, wrong source image, duplicate submission, or user-abandoned request.
3. Call the task cancellation endpoint with that task ID and your standard TokenLab authentication.
4. Read the response status. Do not assume success purely from sending the request; confirm the exact status code TokenLab returns for a successful cancel in the current docs, since it was not captured in this evidence set.
5. Poll the task status endpoint to confirm the task state actually transitioned to cancelled before you remove it from your active job tracking.
6. If cancellation is rejected because the task is already processing, fall back to letting it complete and discarding the output, rather than retrying the cancel call repeatedly.

Seedance Cancellation Verification Checklist

Verify each item against the task cancellation API reference before you wire cancellation into a production path:

• Exact HTTP method and path for the cancellation call, and confirm it is current
• Authentication header format required for the cancellation call
• The success status code for cancelling a queued task (commonly 200 or 204 for delete-style operations under REST convention, not confirmed here for this specific endpoint)
• The status code and error body returned when a task cannot be cancelled because it is already processing or in a terminal state (commonly 404 or 409 under REST convention for state-conflict rejections, not confirmed here)
• The exact field name and value representing the cancelled state in a task status response
• Whether cancelled tasks remain queryable via the standard status endpoint, and for how long
• Whether image-to-video or reference-to-video (multimodal) Seedance task types support cancellation the same way text-to-video does
• Any billing, hold, or refund behavior specific to cancellation, confirmed directly with TokenLab support or billing docs

If your integration submits image-to-video or reference-to-video Seedance requests, treat the exact multimodal request payload (image reference fields, reference-to-video parameters) as unverified in this evidence set. Confirm field names and structure in the Seedance API guide and API reference before production use, separately from the cancellation behavior covered here.

When to Use Cancellation

Scenario	Why cancellation helps
Wrong prompt submitted	Stop the job before it produces output you will not use
Wrong source image or video attached	Catch input validation failures after submission, before generation
Duplicate submit (double-click, retry storm)	Cancel the redundant copies, keep the first valid task running
User abandons the request mid-flow	Tab closed, upload cancelled, or the user changed their mind before generation started
Queue backlog makes a job stale	If the job is no longer relevant to the session that requested it, cancel rather than let it complete unused

Cancellation is not a substitute for input validation before submission, and it is not useful once a job is already processing and you are simply impatient for it to finish. Validate first. Cancellation is the safety net for jobs that should never have been queued.

Video Provider Cost Comparison (Provider Docs Snapshot)

This table reflects provider list pricing from official documentation, not TokenLab rates, and is included for cost-context only. Use it to understand market pricing conventions, not to infer what TokenLab charges. See the TokenLab live snapshot table above for TokenLab's own Seedance rates.

Provider / model	Price basis	Rate	Failure/cancel billing note	Source	Observed
PixVerse V6, 720p no audio	per second	9 credits/s ($1 = 5 videos, 720p/5s Starter pack)	Not stated in evidence	PixVerse Platform Docs	2026-07-08
PixVerse V6, 720p no audio (fal)	per second	$0.045/s	Not stated in evidence	fal PixVerse V6 model page	2026-07-08
Veo 3.1 Standard, 720p/1080p with audio	per second	$0.40/s	Charged only if video is successfully generated when an audio issue blocks output	Google AI Gemini API pricing	2026-07-08
Veo 3.1 Fast, 720p with audio	per second	$0.10/s	Same audio-failure clause as Standard	Google AI Gemini API pricing	2026-07-08
MiniMax Hailuo 2.3, 768p/6s	per point	1 point, approx $0.266 (computed: $1,000 / 3,760 points, Standard package)	Generation failures and security-review videos do not deduct points	MiniMax API video packages	2026-07-08
Runway seedance2, 480p/720p	per second	36 credits/s ($0.01/credit = $0.36/s)	Not stated in evidence	Runway API pricing	2026-07-08
Kling video API	per unit	1 Unit approx $0.14 (list price snapshot)	Not stated in evidence; verify at publish time	Kling AI Developer Platform pricing	2026-07-08

Where a provider explicitly documents a non-deduction clause for failed generations (Veo, MiniMax), that is a strong signal that output-based billing with no charge on failure is a normal industry pattern, not an edge case. It supports the reasoning above without substituting for a direct TokenLab statement.

Integration Checklist for Async Video Queues

• Store the task ID returned at creation time in your job table or session state.
• Add a cancellation path triggered by your own duplicate-detection logic, not just direct user action, so retry storms get cleaned up automatically.
• Handle a rejected cancel response gracefully. If a task has already moved to processing, do not treat the rejection as fatal; fall back to waiting for the result and discarding it if needed.
• Poll the task status endpoint after a cancel call to confirm the state actually changed, rather than assuming success from the cancel response alone. Use the async jobs and polling guide as your reference implementation.
• Add cancellation as an explicit step in "user closed the app" or session-teardown logic, so abandoned jobs do not run to completion for no one.
• Log cancelled tasks the same way you log completed and failed ones. This is useful for spotting patterns in duplicate submissions or weak input validation.
• Confirm the exact billing behavior for cancelled tasks with TokenLab support or billing docs before you rely on it in a cost model, especially at high queue volume.

Limitations

• TokenLab has not published a cancellation-specific billing or refund statement in the evidence reviewed for this article. The "no output, no charge" reasoning above is inferred from the output-only per-token pricing structure of Seedance on TokenLab, not a confirmed policy statement.
• Exact HTTP status codes for successful and rejected cancellation attempts are not documented in this evidence set. This article states expected REST conventions only, not confirmed TokenLab behavior, and deliberately omits a fabricated code sample rather than guess at codes.
• No captured sample task object showing the cancelled state was available for this refresh. Confirm the exact response field and value in the API reference.
• No request/response payload or authentication header format for the cancellation call was captured in this evidence pull. This article does not include a cURL example or SDK snippet as a result. That omission is intentional, not an oversight.
• Provider comparison numbers in this article reflect documented list pricing observed 2026-07-08. Actual invoiced cost can differ after package tiers, volume discounts, and taxes.

FAQ

Do I get charged for a Seedance task I cancel before it starts processing?

TokenLab's live pricing for all six Seedance tiers prices input at zero and charges only on generated output tokens. A task cancelled before processing starts has produced no output, so it should not incur a Seedance generation charge under that structure. This is an inference, not a confirmed TokenLab cancellation billing statement (see the confirmed/inferred table above). TokenLab has not published whether a separate hold or reservation charge exists at submission time. Verify with TokenLab billing docs or support before relying on this for volume cost planning.

Are API credits refunded if I cancel a queued Seedance task?

Unconfirmed in this evidence set. Because Seedance billing is output-only, a cancelled queued task most likely never generates a chargeable line item in the first place, rather than being charged and then refunded. TokenLab has not published this mechanic explicitly. Confirm the exact behavior in your TokenLab billing dashboard or with support.

Does cancelling a queued video task save cost compared to letting it finish?

Based on Seedance's output-only pricing, yes for the generation charge itself, since cancelling before processing means no output tokens are produced. Other providers document a similar pattern explicitly: Google states Veo 3.1 users are charged only if a video is successfully generated when an audio issue blocks output, and MiniMax states failed generations do not deduct points. TokenLab's own cancellation billing statement was not available in this evidence set.

What HTTP status codes does the Seedance cancellation endpoint return?

Not documented in this evidence set. Expect standard REST conventions (success in the 2xx range, conflict or not-found in the 4xx range for tasks already processing or terminal), but confirm the exact codes in the task cancellation API reference before writing status-code-based retry or fallback logic.

Is there a Seedance cancellation API code example I can copy?

Not in this article, and deliberately so. This evidence pull did not capture a verified request/response payload, header format, or status codes for the cancellation endpoint. Publishing a guessed example would risk shipping the wrong field name or status code into your retry logic. Use the verification checklist above against the live API reference instead.

How do I cancel a Seedance video job?

Store the task ID from creation, detect the cancellation trigger, call the cancellation endpoint with that ID and your API key, check the response status against the current docs, then poll task status to confirm the state actually changed to cancelled.

Can I cancel a Seedance task that is already processing?

Generally no. Cancellation targets queued tasks. Once a task has moved into active processing, cancellation is expected to be rejected. Check the response from the cancel call rather than assume it worked.

Does every Seedance task type support cancellation, including image-to-video?

Support can vary by task and model combination. Check the current API reference before relying on cancellation as a guarantee for image-to-video or reference-to-video (multimodal) task types specifically, since coverage may differ from text-to-video.

Related Reading and Next Step

Task cancellation for queued Seedance jobs gives you a way to stop bad or duplicate video requests before they run, but it works best alongside a clear read on the broader video generation landscape and cost structure. For background on where Seedance fits in common workflows, see the Seedance API Guide: When to Use It for AI Video Generation. If you are comparing providers before committing to a model, the Best AI Video Models API Guide covers selection criteria, and AI Video API Pricing in 2026 breaks down cost structures across services in more depth than the comparison table above. For the polling half of the task lifecycle, pair this article with the async jobs and polling guide.

Model availability, pricing, and endpoint behavior change frequently. Verify current status codes, response schemas, and billing behavior against the live API reference before shipping cancellation into a production path. Ready to test cancellation and other queue controls yourself? Create an API key and get started today.