· reAPI Team
Kie AI task status: stuck at 99% or still processing?
Read Kie AI task status when a generation stays at 99%. Check the original task, result, callback and credit record before deciding whether to submit another.

The progress bar has reached 99%. The video still is not there. Before you click Generate again, find the task ID from the first attempt: that is how you tell whether you are waiting for a video or waiting for your app to notice a video that already exists.
Kie AI task status comes from the task record. For Market jobs, that record distinguishes waiting, generation, success and failure, and carries the result or error alongside the state.[1] A percentage on its own cannot make the next decision for you. Start with the existing task, then follow the branch that its response actually supports.
Find the task that produced the progress bar
Open the response from your original submission. If you used Kie's Market API, look for the returned taskId. The lookup is GET /api/v1/jobs/recordInfo?taskId=...; it retrieves jobs created with POST /api/v1/jobs/createTask. Other endpoint families need their own documentation. A synchronous chat request, for example, does not produce a Market task to poll.[2][1]
If you use the website, Kie's Logs area is the documented place to find submitted tasks, their parameters and results.[3] In an automation, inspect the output of the submission node. Copy the ID from there rather than from a later retry: two submissions with the same prompt are still two attempts to keep track of.
For your own app, save the provider ID next to the customer's job reference. Imagine a scheduled post called friday-demo with a video still pending. The schedule name tells you what the video is for; the provider ID tells you which generation to retrieve. That is a suggested record layout, not a Kie feature. Keeping both lets you restart your worker without restarting the creative job.
No task ID at all? Go back to the submission logs before changing the prompt. A lost response leaves the first submission unresolved. You need to establish whether it was accepted, through the available account history or support, before treating a second submission as a harmless retry.
Read the response before changing the workflow
There are two checks before you get to the task's state. First inspect the HTTP response. Then inspect the JSON code. Kie's task reference documents business errors inside HTTP 200 responses, including invalid credentials and missing, nonexistent or differently owned task IDs. It also lists HTTP error responses. Handling only one of those forms leaves a gap.[1]
This matters when a workflow appears stuck. If your poller keeps receiving a lookup error but the screen keeps displaying its last progress value, another minute of staring at the percentage will not tell you what the task is doing. Compare the ID and account with the original submission. Save the error body without the API key. Fix the lookup before diagnosing generation.
Once the lookup succeeds, read data.state:
waitingandqueuingmean the task is waiting in a queue.generatingmeans processing is in progress.successmeans you can inspect the returned result.failmeans you should inspectfailCodeandfailMsg.
Those are the Market API's documented states.[1] An unrecognized value deserves its own handling in your client; silently treating it as failure would turn a response you do not understand into a reason to generate again.
The following decoder separates those cases. It operates on a response your server has already fetched. There is no submission or automatic retry in it.
function inspectMarketTask(httpStatus, body) {
if (httpStatus < 200 || httpStatus >= 300) {
return { kind: 'lookup_error', httpStatus };
}
if (body?.code !== 200 || !body.data) {
return { kind: 'lookup_error', code: body?.code, message: body?.msg };
}
const task = body.data;
if (['waiting', 'queuing', 'generating'].includes(task.state)) {
return { kind: 'pending', taskId: task.taskId, state: task.state };
}
if (task.state === 'fail') {
return {
kind: 'failed', taskId: task.taskId,
code: task.failCode, message: task.failMsg,
credits: task.creditsConsumed,
};
}
if (task.state !== 'success') {
return { kind: 'unknown_state', taskId: task.taskId, state: task.state };
}
let result;
try { result = JSON.parse(task.resultJson); }
catch { return { kind: 'result_unreadable', taskId: task.taskId }; }
const urls = result?.resultUrls;
if (!Array.isArray(urls) || !urls.length ||
urls.some(url => typeof url !== 'string' || !url.trim())) {
return { kind: 'output_missing', taskId: task.taskId };
}
return { kind: 'ready', taskId: task.taskId, urls };
}The kind labels belong to this example. The output check covers media jobs whose parsed resultJson contains resultUrls; it does not cover every model's output. Text and subject-detection models have different structures.[1] Even ready only says that the expected URL strings are present. Downloading and checking the actual file is still ahead.
If it succeeded, follow the file
For a successful media job, parse resultJson as JSON and look for the expected URLs. The field is a JSON string, so reading task.resultJson.resultUrls as though it were already an object will not retrieve the array described in the documentation.[1]
Then work forward from the response. Does it contain the expected media field? Can your server download that URL? Did the storage step save the bytes? Does the page point to the saved file? Each answer narrows where to resume. A failed upload to your storage is a reason to repeat that upload while the source file remains available, not a reason to buy another generation.
For example, suppose your logs show a successful task followed by a failed archive upload. This is a hypothetical debugging case. Keep the successful task ID attached to the job, retrieve its result if needed, and restart the archive step. If you instead run the workflow from its first node, you have sent the same creative request through generation again without addressing the storage failure.
Save useful outputs promptly. Kie's homepage lists a 14-day media retention period, but the Market reference describes a one-hour URL validity window for OmniHuman 1.5 Subject Detection. The model-specific exception matters.[3][1] A successful task record and a permanently downloadable file are different things. Keep the downloaded file, the original ID and the response together so that a later missing URL does not erase your record of what happened.
If it is still generating, let the same task finish
Kie's guidance recommends callbacks for production and exponential backoff for polling, starting at intervals of two to three seconds. It also says some video tasks take longer than ten minutes.[1] That is enough to reject a universal “ten minutes means failed” rule. It is not a promise that every delayed task will eventually succeed.
Your application can stop waiting before the task stops running. A scheduled post has a deadline; a browser session has a user's patience to consider. Decide what happens when your own waiting limit expires. A useful local outcome is “needs attention,” with the task ID retained for later lookup. Calling it “failed” without a terminal response makes the next operator think the generation has ended when you have only stopped observing it.
If you configured callBackUrl, check the callback path as well. Kie supports notifications for successful and failed tasks. Its verification scheme signs the task ID and timestamp rather than the whole response body, and its guidance points back to authenticated task lookup for the authoritative result.[4]
Use the notification to wake up the existing job. Retrieve its state, then run the same completion handling you would use after polling. If a poll already recovered the video, a later callback should find that completed local job. Design that handler so it cannot publish the same post again simply because the completion arrived through another path.
In n8n, restart from the step that needs work
The setting to inspect is Retry on Fail on the HTTP Request node. n8n documents that it retries the node that failed.[5] Read the operation inside that node before turning it on.
A node that queries a known task can repeat the lookup. A node that sends the generation POST repeats a submission. Those operations should not share a retry decision just because both happen to use HTTP. If a larger workflow wraps submission, waiting and download into one restartable step, break out the saved task ID so recovery can enter after submission.
For the hypothetical archive failure above, the resume point is the download or storage node. For a lost callback, it is lookup. For state: fail, read the failure first and decide whether a changed request is warranted. For an unknown submission outcome, stop automatic replay while you reconcile the first attempt.
The daily video workflow guide shows a durable-job approach on reAPI. Its API fields are different from Kie's, but the useful design choice is the same: preserve enough state to continue unfinished work without repeating finished work.
If it failed, keep the error beside the charge
Kie says failed tasks are not charged. The task response also exposes creditsConsumed, along with the state, error fields and timestamps.[3][1] Compare those records for the particular attempt. A change in your overall balance cannot identify what happened to one video if several other jobs were running.
If you already clicked Generate again, keep both IDs in the investigation. The first task might be the one represented by the progress bar, while the second is the one whose charge you are looking at. Match each response to its own submission before asking for a billing correction.
For support, put the task ID and model first, followed by the submission time and time zone, latest response, error message and relevant credit entry. Say where the work stopped: no terminal state, successful result with no usable URL, failed download, or an apparent billing mismatch. Kie's homepage directs technical questions to its support groups.[3] Remove credentials and unrelated private inputs from anything you share.
The failed-task policy does not let this article promise a refund for an individual account. It gives you a specific discrepancy to ask support to resolve. If the task succeeded but the video did not meet your brief, describe that separately; a quality complaint and a recorded generation failure are different support questions.
Carry the recovery logic with you if you change APIs
If recurring recovery work leads you to evaluate reAPI, start with the task response. Ordinary media jobs use processing, completed and failed; results sit under output, and usage.credits reports settled consumption. Polling a known task does not consume credits.[6] Map those fields explicitly instead of reusing a Kie response decoder unchanged.
There are limits to account for. reAPI callbacks are unsigned, so verify a known pending task through authenticated lookup; delivery information is available with ?include=webhook.[7] Repeating a generation POST with Idempotency-Key does not deduplicate it, and some model-specific post-generation safety failures retain a charge.[8][6] Keep the saved-attempt and settlement checks when you migrate.
Use the model catalog to check the model you need and the Kie comparison for the broader selection question. Neither a platform change nor a second POST settles the video already sitting at 99%. For that one, go back to its task ID and resume from the last step whose result you can establish.
References
- Kie AI. Get Task Details, Market API. Retrieved November 15, 2026.
- Kie AI. Market quickstart and unified API structure. Retrieved November 15, 2026.
- Kie AI. Homepage frequently asked questions: tasks, support, retention and trial credits. Retrieved November 15, 2026.
- Kie AI. Webhook Security Verification. Retrieved November 15, 2026.
- n8n. HTTP Request node common issues: Retry on Fail. Retrieved November 15, 2026. HTTP Request troubleshooting.
- reAPI. Tasks. Reviewed November 15, 2026. Task polling documentation.
- reAPI. Webhooks. Reviewed November 15, 2026. Delivery and verification contract.
- reAPI. API overview. Reviewed November 15, 2026. Submission and idempotency documentation.