GPT Image 2.5 is live — OpenAI's newest image model, targeted edits that leave the rest of the frame alone
All resources

· reAPI Team

fal API status: COMPLETED but no result

Understand fal API status when COMPLETED returns no result. Check result responses, errors, output fields and webhooks before retrying a generation request.

fal API status: COMPLETED but no result

COMPLETED is an unfortunate place to stop reading. In fal's queue API, it means the request has ended, including requests that failed or were cancelled. It does not say that a usable image or video was produced.[1]

The next call is to the original request's result endpoint. That response carries the model's HTTP status and body.[2] If your app has turned the progress indicator green but cannot find a file, follow that result before submitting another generation. You may be missing one retrieval step, reading the wrong JSON object, or looking at an actual model error.

Status tells you when to fetch the result

fal's queue status moves through IN_QUEUE, IN_PROGRESS and COMPLETED. Once it reaches COMPLETED, read the result. Fields such as metrics.inference_time and any available error information are useful context, but they do not replace the model response.[1]

This separation is visible in fal's own API examples: submit the request, fetch its status, then get its result and consult the model's Output Schema. The JavaScript client's fal.queue.status() and fal.queue.result() perform different operations. In Python, the completed status is followed by handler.get().[3][4]

Look at the variable your application is passing to the image component. If it contains queue status, you have not reached the object that the component needs. Fetch the result first. If it contains the JavaScript SDK result wrapper, read its data property before applying the model's output schema.[3] Changing images to image by trial and error is less useful than checking which response you actually have.

The calling method matters here. subscribe() submits and waits through the queue for you, while submit() returns control so your application can manage the lifecycle. Direct run() does not use the queue.[4] An example written for one method may therefore contain a waiting or unwrapping step your code still needs, or one it has already performed.

Use the URLs returned by the original submission

Save request_id, status_url and response_url when the submission succeeds. fal's queue guide recommends using the returned URLs. If you construct query URLs yourself, its guide distinguishes the owner/app path from the full model endpoint path used to submit work.[3] Appending every model suffix to a request-status route can send the lookup to the wrong place.

For a worker that may restart, save those values outside the process before waiting. Your local job can then continue by reading the same request. This is an application design recommendation: a retry button should not need to reconstruct the original submission simply to discover whether its result exists.

The following JavaScript reads a saved request from your server. The URLs must come from that server's trusted fal submission response, not arbitrary browser input: the request attaches your API credential.

async function inspectFalRequest(saved, key) {
  async function read(url) {
    const response = await fetch(url, {
      headers: { Authorization: `Key ${key}` },
      redirect: "error",
    });
    const raw = await response.text();
    let body;
    try {
      body = JSON.parse(raw);
    } catch {
      body = raw;
    }
    return { http: response.status, ok: response.ok, body };
  }

  const state = await read(saved.status_url);
  const lifecycle = state.body?.status;
  if (!state.ok || !["IN_QUEUE", "IN_PROGRESS", "COMPLETED"].includes(lifecycle)) {
    return { stage: "status-read-error", ...state };
  }
  if (lifecycle !== "COMPLETED") {
    return { stage: "pending", ...state };
  }

  const result = await read(saved.response_url);
  return { stage: "result", ...result };
}

The helper deliberately preserves a non-JSON response as text. Otherwise a failed JSON parse could replace the useful error with another exception. A connection failure still throws to the caller; retain the saved request so the next recovery step can inspect the same job. The function makes no generation POST.

Its ok flag is the HTTP result of the read, not a statement that your product has a usable asset. You still need to inspect the body. Likewise, status-read-error means this lookup did not establish the queue state. It does not mean the remote generation failed.

In Python, inspect the exception handling around handler.get() as well as the call itself. A broad handler that returns None for every exception leaves the next part of your app with an empty value and no explanation. Preserve the exception information for diagnosis, and give the application a distinct error path. Do not let the same empty value represent a request that is still pending, a rejected input and a successfully generated file that has not yet been downloaded.

During JavaScript debugging, a sanitized record of the response's field names can reveal a mistaken object path. Keep credentials and private input content out of shared logs. Once the path is established, validate the required fields before passing the result to your image or video component.

If authentication is the problem, check the account that created the task. fal keys are created in the dashboard's Keys area and belong to the selected account. Keep the credential on your server, commonly in FAL_KEY; raw requests use Authorization: Key ....[5] Creating a key under a different account will not move an existing request into that account. Do not put a working key into browser code to make debugging easier.

Read the failure where it occurred

A result response can explain why a completed request has no media. fal documents the following result statuses:[2]

Result responseWhat to inspect
400, request still in progressReturn to the saved status URL and continue observing that request
401The credential, header and account used for the lookup
404The request ID, query URL, account and applicable retention rules
422The returned validation or model error
499The recorded cancellation
500 or another server errorThe actual response body and request ID

Do not collapse the last row into a connection timeout. Receiving a model error from the result endpoint gives you a response to inspect. Failing to reach the endpoint leaves you without that response. The recovery decisions differ.

For example, no_media_generated is a documented 422 model error: generation ended without producing the expected media. fal marks it non-retryable.[6] That is a specific diagnosis when the returned error says so. An empty image component is not enough to assign that diagnosis yourself.

Keep the error shape intact. Request errors can have a string detail and an error_type; model validation errors can contain a detail array with typed entries. fal also notes that some endpoints have not adopted the newer model-error format.[6][7] A parser that expects every error to have one shape can hide the message you need most.

When the result reports a file-input error, inspect the source file as well. A URL that works in your signed-in browser may not be publicly retrievable by the service. fal's file guidance requires accessible input URLs and notes that hosts can block or rate-limit requests.[8] Check that condition before changing the output parser; an input-fetch failure and an output-field mistake occur at different stages.

“API call failed” in an app is therefore a starting point for investigation, not the explanation. Record which call failed and keep its status and body. If you are deciding whether the failure should have cost credits, use the failed-request billing guide after identifying the actual request outcome.

A successful JSON response still needs a media check

Open the Output Schema for the exact endpoint you submitted to. Selected image models return an images array, while other models use other structures. Some expose sync_mode, which can return media as a data URI and omit the output from request history.[8] Those are model-specific details. A generic handler that assumes every result contains one downloadable video.url will not cover them.

Suppose, instead, the model response contains the expected output URL, but your storage upload failed. This is a hypothetical recovery case. Keep the URL and original request ID, retry the file-transfer step while the file remains available, and verify that the saved bytes can be read. Running generation again would produce a new operation without explaining what happened to the original file.

This is also where an API migration needs an explicit field mapping. Ordinary reAPI media tasks return their business status and media arrays in one task response, with output.image_urls or output.video_urls. The task reference and error reference distinguish a missing media result from a failure to save the generated file.[9][10] Even there, an HTTP 200 is not enough: read the task's status and validate what your application needs. Changing providers does not remove the file-handling step.

Webhooks add another object to keep straight

fal webhook statuses use OK and ERROR, rather than the queue lifecycle values. An OK notification can have payload: null and payload_error when the result cannot be represented as JSON. Its documentation directs you back to the queue result for recovery.[11]

If your workflow is driven by webhooks, inspect the whole notification before deciding there is no result. A parser written for the queue's status field should not be reused unchanged for the webhook's status and payload. Match the notification to the existing request, then retrieve the result if that is what its fields call for.

For long jobs, fal recommends queue status and webhooks instead of keeping a blocking call open indefinitely.[3] Keep a lookup route in your own workflow even when callbacks are the normal path. A missed notification should leave you with an ID to investigate, not force a new generation to get the workflow moving again.

Save completed results promptly. Queue-result availability, request-history payload storage and media-file retention are separate concerns; result size and storage settings can affect them differently.[2][11][12] If you need the file later, copy it into storage you control and record whether that copy succeeded. A saved URL alone is not an archive.

When to check for an outage

If the original result cannot be retrieved, compare the failure time and affected service with fal's official status page and incident history. That page separates components, so look at the part relevant to your request rather than treating any notice as an explanation for every error.[13] This article does not give a live uptime assessment.

A completed status with no displayed file does not by itself establish that fal is down. Nor does the absence of a status notice prove your code is wrong. The useful next evidence is still the original result response: its HTTP code, body, endpoint and request ID. Once you have that, you can decide whether to fix retrieval, correct an input, recover a file or escalate an unresolved service error.

References

  1. fal. Get request status. Queue API reference. Retrieved November 15, 2026.
  2. fal. Get request result. Queue API reference. Retrieved November 15, 2026.
  3. fal. Queue. Model APIs inference guide. Retrieved November 15, 2026.
  4. fal. Inference Methods: How to Call fal Models. Retrieved November 15, 2026.
  5. fal. Get Your API Key. Retrieved November 15, 2026.
  6. fal. Model Errors. Including the no_media_generated entry. Retrieved November 15, 2026.
  7. fal. Request Errors. Model APIs guide. Retrieved November 15, 2026.
  8. fal. FLUX.1 [dev] API. Files and Schema sections. Retrieved November 15, 2026.
  9. reAPI. Tasks. reapi.ai/docs/api/tasks. Retrieved November 15, 2026.
  10. reAPI. Errors. reapi.ai/docs/api/errors. Retrieved November 15, 2026.
  11. fal. Webhooks. Model APIs inference guide. Retrieved November 15, 2026.
  12. fal. Data Retention. Model APIs guide. Retrieved November 15, 2026.
  13. fal. fal Status. Official status-page interface checked November 15, 2026; no uptime assessment is asserted here.
All resources