Retrieve Job Status

November 17, 2025 (November 16, 2026)

Table of contents

  1. Request Headers
  2. Path Parameters
  3. Responses
  4. Model
  5. Missing media URLs
    1. How to get the link
  6. Examples
  7. Try It

Retrieve the status and details of a specific image or video generation job by its job ID.

This endpoint is particularly useful when using async mode for video generation, or when tracking job progress via webhooks using the replyUrl parameter.

To get load balancing statistics across all jobs, use GET /jobs.

A job stays created while the request that submitted it is still solving the captcha. If that request ends early — most often because the client closed the connection before the API answered — the job can no longer progress, and after 30 minutes it is reported as failed with an explanation. Submit it again, and give POST requests several minutes before timing out, since captcha retries can take that long.

https://api.useapi.net/v1/google-flow/jobs/jobId

Request Headers

Authorization: Bearer {API token}

Path Parameters

Responses

  • 200 OK

    Returns the job record with current status and details.

    Video job (completed):

    {
      "jobid": "j1111190012345482913v-u12345-email:john@gmail.com-bot:google-flow",
      "type": "video",
      "status": "completed",
      "created": "2026-11-11T19:00:12.345Z",
      "updated": "2026-11-11T19:01:44.806Z",
      "request": {
        "email": "john@gmail.com",
        "prompt": "A serene mountain landscape at sunset with camera slowly panning right",
        "model": "veo-3.1-fast",
        "aspectRatio": "landscape",
        "count": 1,
        "async": true,
        "replyUrl": "https://your-domain.com/webhook"
      },
      "response": {
        "operations": [],
        "media": [
          {
            "name": "a1d95d21-75d2-482d-a354-14ef8802ce66",
            "projectId": "9f63078c-...redacted...",
            "workflowId": "fa986834-...redacted...",
            "mediaMetadata": {
              "createTime": "2026-11-11T19:01:04.498540Z",
              "mediaTitle": "A serene mountain landscape at sunset with camera slowly panning right",
              "mediaBlobSize": "3816736",
              "mediaStatus": { "mediaGenerationStatus": "MEDIA_GENERATION_STATUS_SUCCESSFUL" },
              "visibility": "PRIVATE",
              "requestData": {
                "videoGenerationRequestData": {
                  "backend": "flow",
                  "statusEnum": 3,
                  "aspectEnum": 2,
                  "videoModelControlInput": {
                    "videoModelName": "veo_3_1_t2v_fast",
                    "videoGenerationMode": "VIDEO_GENERATION_MODE_TEXT_TO_VIDEO",
                    "videoAspectRatio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
                    "videoResolution": "VIDEO_RESOLUTION_720P"
                  }
                },
                "promptInputs": [
                  { "structuredPrompt": { "parts": [ { "text": "A serene mountain landscape at sunset with camera slowly panning right" } ] } }
                ]
              }
            },
            "video": {
              "generatedVideo": {
                "seed": 818896,
                "prompt": "A serene mountain landscape at sunset with camera slowly panning right",
                "model": "veo_3_1_t2v_fast",
                "baseImageMediaGenerationId": "",
                "isLooped": false,
                "aspectRatio": "VIDEO_ASPECT_RATIO_LANDSCAPE"
              },
              "dimensions": { "length": "8s" },
              "operation": { "name": "a1d95d21-75d2-482d-a354-14ef8802ce66" }
            },
            "mediaGenerationId": "user:12345-email:6a6f...-video:a1d95d21-75d2-482d-a354-14ef8802ce66",
            "videoUrl": "https://flow-content.google/video/a1d95d21-75d2-482d-a354-14ef8802ce66?Expires=...",
            "thumbnailUrl": "https://flow-content.google/image/a1d95d21-75d2-482d-a354-14ef8802ce66?Expires=..."
          }
        ],
        "remainingCredits": 14845,
        "captcha": {
          "service": "CapSolver",
          "taskId": "b0bf7514-...redacted...",
          "durationMs": 3159,
          "attempts": [
            {
              "service": "CapSolver",
              "success": true,
              "durationMs": 3159,
              "taskId": "b0bf7514-...redacted...",
              "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36",
              "secChUa": ""
            }
          ]
        }
      }
    }
    

    Image job (completed):

    {
      "jobid": "j1108065148191735260i-u12345-email:jane@gmail.com-bot:google-flow",
      "type": "image",
      "status": "completed",
      "created": "2026-11-08T06:51:48.191Z",
      "updated": "2026-11-08T06:52:24.683Z",
      "request": {
        "email": "jane@gmail.com",
        "prompt": "A serene mountain landscape at sunset with vibrant colors",
        "model": "nano-banana-2",
        "aspectRatio": "16:9",
        "count": 1,
        "replyUrl": "https://your-domain.com/webhook",
        "replyRef": "custom-reference-123"
      },
      "response": {
        "media": [
          {
            "name": "ee2a8a64-d534-46fd-b834-e778a7f54d93",
            "workflowId": "b0b8b280-...redacted...",
            "image": {
              "generatedImage": {
                "seed": 515151,
                "mediaGenerationId": "user:12345-email:616e...-image:ee2a8a64-d534-46fd-b834-e778a7f54d93",
                "mediaVisibility": "",
                "prompt": "A serene mountain landscape at sunset with vibrant colors",
                "modelNameType": "BELUGA",
                "workflowId": "b0b8b280-...redacted...",
                "fifeUrl": "https://flow-content.google/image/ee2a8a64-d534-46fd-b834-e778a7f54d93?Expires=...&KeyName=labs-flow-prod-cdn-key&Signature=...",
                "aspectRatio": "IMAGE_ASPECT_RATIO_LANDSCAPE",
                "requestData": {
                  "promptInputs": [ { "textInput": "A serene mountain landscape at sunset with vibrant colors" } ],
                  "imageGenerationRequestData": {
                    "backend": "flow",
                    "referencesApplied": { "media": [], "entities": [] },
                    "aspectEnum": 3,
                    "modelEnum": 36
                  }
                }
              },
              "dimensions": { "width": 1376, "height": 768 }
            }
          }
        ],
        "captcha": {
          "service": "EzCaptcha",
          "taskId": "bded30b6...redacted...",
          "durationMs": 2702,
          "attempts": [
            {
              "service": "SolveCaptcha",
              "success": false,
              "durationMs": 194,
              "error": "SolveCaptcha submit failed: ERROR_ZERO_BALANCE"
            },
            {
              "service": "EzCaptcha",
              "success": true,
              "durationMs": 2502,
              "taskId": "bded30b6...redacted...",
              "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36",
              "secChUa": "\"Not:A-Brand\";v=\"8\", \"Chromium\";v=\"156\", \"Google Chrome\";v=\"156\""
            }
          ]
        }
      }
    }
    

    Job failed:

    {
      "jobid": "j1111130012345906417i-u12345-email:jane@gmail.com-bot:google-flow",
      "type": "image",
      "status": "failed",
      "created": "2026-11-11T13:00:12.345Z",
      "updated": "2026-11-11T13:00:45.678Z",
      "request": {
        "email": "jane@gmail.com",
        "prompt": "Generate an image",
        "model": "nano-banana-2"
      },
      "error": "API error: 500",
      "code": 500,
      "response": {
        "error": {
          "code": 500,
          "message": "flow.google.com ogiZ0b failed",
          "status": "INTERNAL",
          "details": []
        },
        "captcha": {
          "service": "CapSolver",
          "taskId": "e1710fcf-...redacted...",
          "durationMs": 4064,
          "attempts": [
            {
              "service": "CapSolver",
              "success": true,
              "durationMs": 4064,
              "taskId": "e1710fcf-...redacted..."
            }
          ]
        }
      }
    }
    
  • 401 Unauthorized

    Invalid API token.

    {
      "error": "useapi.net ⁝ Unauthorized",
      "code": 401
    }
    
  • 403 — the jobid does not belong to your account.

  • 404 Not Found

    Job not found in database.

    {
      "error": "Job not found",
      "code": 404
    }
    
  • 400 Bad Request

    Invalid job ID format, or the job belongs to a different user.

    {
      "error": "Invalid job ID format",
      "code": 400
    }
    
    {
      "error": "Access denied - job belongs to different user",
      "code": 400
    }
    
  • 410 Gone

    Job has expired (jobs are retained for 7 days).

    {
      "error": "Job has expired",
      "code": 410
    }
    

Model

A job record has one of three shapes: a video job (POST /videos, /videos/upscale and /videos/extend), an image job (POST /images) or a concatenation job (POST /videos/concatenate). The request holds what you sent after validation, so each reference id you sent comes back as a Reference object, and every parameter you sent is kept, captcha settings included.

The job record for each job type, field by field, and the types it uses (VideoRequest, UpscaleRequest, ExtendRequest, Reference, Captcha, GoogleError)
  • Video generation, upscale and extend jobs.

    {
      jobid: string                       // Unique job identifier
      type: 'video'                       // Job type
      status: 'created' | 'started' | 'completed' | 'failed'  // created: not yet sent to Google; started: Google is generating
      created: string                     // ISO 8601 creation timestamp
      updated?: string                    // ISO 8601 last update timestamp
      model?: string                      // The model that ran, only when it differs from the one asked for: a model Google
                                          // retired is routed to its replacement (from December 5, 2026)
      request: VideoRequest | UpscaleRequest | ExtendRequest
                                          // the request as you sent it, after validation, in the shape of the endpoint you
                                          // called: VideoRequest for POST /videos, UpscaleRequest for POST /videos/upscale,
                                          // ExtendRequest for POST /videos/extend
    
      response?: {                        // set once Google has answered (absent while the job is created)
        operations?: Array<{              // empty for videos and extensions. One item per video for an upscale
          operation: {                    // the upscale operation
            name: string                  // the media id
            metadata?: {                  // filled when the upscale is done
              '@type': string             // Google's media record type name
              name: string                // the media id
              video: {                    // the upscaled video
                seed: number              // the seed Google used
                model: string             // Google's own key for the upscale model
                aspectRatio: string       // VIDEO_ASPECT_RATIO_LANDSCAPE | VIDEO_ASPECT_RATIO_PORTRAIT
                isLooped: boolean         // always false
                prompt?: string           // the prompt, when Google gave one
                upsampleResolution?: string  // e.g. VIDEO_UPSAMPLE_RESOLUTION_1080P
                fifeUrl?: string          // Signed video download URL, same as videoUrl
                servingBaseUri?: string   // Signed thumbnail URL (the video URL when there is none)
                mediaGenerationId: string // Encoded reference ID of the upscaled video
                mediaVisibility?: string  // "PRIVATE"
              }
            }
          }
          sceneId: string                 // always empty
          status: string                  // MEDIA_GENERATION_STATUS_PENDING until the upscale ends, then as the media item's
          mediaGenerationId?: string      // Encoded reference ID of the upscaled video, once done
        }>
        media?: Array<{                   // one item per video asked for (count)
          name: string                    // Media identifier (raw UUID)
          projectId: string               // the Google Flow project the video is in
          workflowId?: string             // the Google Flow workflow of the video
          workflowStepId?: string         // the workflow step, when Google reports one
          mediaMetadata: {                // Google's record of the video
            createTime?: string           // ISO 8601 timestamp
            mediaTitle?: string           // the prompt (absent on an upscale)
            mediaBlobSize?: string        // the video's size in bytes, once done
            mediaStatus: {                // generation status
              mediaGenerationStatus: string  // MEDIA_GENERATION_STATUS_PENDING | MEDIA_GENERATION_STATUS_ACTIVE |
                                             // MEDIA_GENERATION_STATUS_SUCCESSFUL | MEDIA_GENERATION_STATUS_FAILED |
                                             // MEDIA_GENERATION_STATUS_UNKNOWN
              error?: {                   // why generation failed
                code: number              // Google's error code (0 when it gave none)
                message: string           // Google's reason, e.g. "PUBLIC_ERROR_IP_INPUT_IMAGE"
              }
              failureReasons?: string[]   // Google's classifier labels, e.g. ["IP_PROHIBITED"]
            }
            visibility?: string           // "PRIVATE"
            requestData: {                // what Google recorded about the request
              videoGenerationRequestData: {  // Google's generation settings
                backend: 'flow'           // the request went through `flow.google.com`
                statusEnum: number | null // Google's raw status value
                aspectEnum: number | null // Google's raw aspect value
                videoModelControlInput?: {   // the model settings Google ran
                  videoModelName?: string    // Google's own key for the model that ran
                  videoGenerationMode?: string  // e.g. VIDEO_GENERATION_MODE_TEXT_TO_VIDEO
                  videoAspectRatio?: string  // VIDEO_ASPECT_RATIO_LANDSCAPE | VIDEO_ASPECT_RATIO_PORTRAIT
                  videoResolution?: string   // e.g. VIDEO_RESOLUTION_720P
                }
              }
              promptInputs?: Array<object>   // the prompt as Google received it, @-mentions included
              clientPlatform?: string     // "CLIENT_PLATFORM_WEB"
            }
          }
          video: {                        // the video
            generatedVideo?: {            // present once Google has generated the video
              seed: number                // the seed Google used
              prompt: string              // the prompt as Google ran it
              model: string               // Google's own key for the model that ran
              baseImageMediaGenerationId?: string  // empty string
              isLooped: boolean           // always false
              aspectRatio: string         // VIDEO_ASPECT_RATIO_LANDSCAPE | VIDEO_ASPECT_RATIO_PORTRAIT
                                          // (empty when Google did not say)
              upsampleMetadata?: {        // on an upscaled video
                videoUpsampleResolution: string  // VIDEO_UPSAMPLE_RESOLUTION_1080P | VIDEO_UPSAMPLE_RESOLUTION_720P
              }
            }
            dimensions?: {                // present when Google reports the duration
              length: string              // duration string (e.g. "8s")
            }
            operation: {                  // the generation operation
              name: string                // the media id (same as name)
            }
          }
          mediaGenerationId?: string      // Encoded reference ID for use in subsequent API calls, set when the job ends
          videoUrl?: string               // Signed video download URL (MP4, valid ~6h)
          thumbnailUrl?: string           // Signed thumbnail download URL (JPEG, valid ~6h)
        }>
        remainingCredits?: number         // Google Flow credits left on the account, as Google reported them
        failureReasons?: string[]         // Why every video failed, e.g. ["PUBLIC_ERROR_IP_INPUT_IMAGE", "IP_PROHIBITED"].
                                          // Only on jobs where all videos failed, and only when Google gave a reason
        captcha?: Captcha                 // the captcha solve of this job
        captchaAttemptsCount?: number     // how many captcha attempts the submit made. From the submit: present while the job is
                                          // started, and kept when the job fails before Google's result arrives (as are the next three)
        captchaProviders?: string         // the providers of those attempts, in order, comma-separated (e.g. CapSolver,AntiCaptcha)
        tier?: string                     // the account's Google Flow plan tier at submit (e.g. PAYGATE_TIER_TWO)
        sku?: string                      // the account's Google plan code at submit (e.g. G1_TIER2)
        error?: string | GoogleError      // on a failed job, one of two: a string, what went wrong in the API's own words,
                                          // or GoogleError, Google's error as Google returned it
      }
    
      error?: string                      // Error message (if failed)
      code?: number                       // HTTP status code (if failed)
    }
    

    VideoRequest: the request of a POST /videos job.

    {
      email: string                 // the account that ran the job (picked for you when not given)
      prompt: string                // your prompt
      model?: 'veo-3.1-quality' | 'veo-3.1-fast' | 'veo-3.1-lite' | 'veo-3.1-lite-low-priority' | 'omni-flash' | 'omni-flash-1.2'  // the model you asked for
      aspectRatio?: 'landscape' | 'portrait'  // as requested
      duration?: number             // seconds, as requested
      resolution?: '360p' | '720p'  // as requested
      count?: number                // 1-4
      startImage?: Reference        // first frame
      endImage?: Reference          // last frame
      referenceImage_1?: Reference  // reference image (referenceImage_1 to referenceImage_10, as many as you sent)
      referenceImage_2?: Reference  // reference image
      referenceImage_3?: Reference  // reference image
      referenceImage_4?: Reference  // reference image
      referenceImage_5?: Reference  // reference image
      referenceImage_6?: Reference  // reference image
      referenceImage_7?: Reference  // reference image
      referenceImage_8?: Reference  // reference image
      referenceImage_9?: Reference  // reference image
      referenceImage_10?: Reference // reference image
      character_1?: Reference       // character (character_1 to character_10, as many as you sent)
      character_2?: Reference       // character
      character_3?: Reference       // character
      character_4?: Reference       // character
      character_5?: Reference       // character
      character_6?: Reference       // character
      character_7?: Reference       // character
      character_8?: Reference       // character
      character_9?: Reference       // character
      character_10?: Reference      // character
      referenceAudio_1?: string     // a built-in voice name (lowercase) or your voice's reference id, as sent
      referenceAudio_2?: string     // voice, as referenceAudio_1
      referenceAudio_3?: string     // voice, as referenceAudio_1
      referenceAudio_4?: string     // voice, as referenceAudio_1
      referenceAudio_5?: string     // voice, as referenceAudio_1
      referenceVideo_1?: Reference  // the video to edit
      startFrameIndex_1?: number    // edit window start frame, as requested
      endFrameIndex_1?: number      // edit window end frame, as requested
      captchaToken?: string         // your own captcha token, as sent
      captchaRetry?: number         // as requested
      captchaOrder?: string[]       // the captcha providers you named, in your order
      async?: boolean               // Fire-and-forget mode
      replyUrl?: string             // Webhook URL for callbacks
      replyRef?: string             // Custom reference for callbacks
    }
    

    UpscaleRequest: the request of a POST /videos/upscale job.

    {
      email: string                 // the account of the source video
      mediaGenerationId: Reference  // the video to upscale
      resolution?: '720p' | '1080p' | '4K'  // as requested
      captchaToken?: string         // your own captcha token, as sent
      captchaRetry?: number         // as requested
      captchaOrder?: string[]       // the captcha providers you named, in your order
      async?: boolean               // Fire-and-forget mode
      replyUrl?: string             // Webhook URL for callbacks
      replyRef?: string             // Custom reference for callbacks
    }
    

    ExtendRequest: the request of a POST /videos/extend job.

    {
      email: string                 // the account of the source video
      prompt: string                // your prompt
      mediaGenerationId: Reference  // the video to extend
      model?: 'omni-flash-1.2' | 'veo-3.1-quality' | 'veo-3.1-fast' | 'veo-3.1-lite' | 'veo-3.1-lite-low-priority'  // the model you asked for
      duration?: number             // seconds to add, as requested
      resolution?: '360p' | '720p'  // as requested
      referenceImage_1?: Reference  // reference image
      referenceImage_2?: Reference  // reference image
      referenceImage_3?: Reference  // reference image
      character_1?: Reference       // character
      character_2?: Reference       // character
      character_3?: Reference       // character
      referenceAudio_1?: string     // a built-in voice name (lowercase) or your voice's reference id, as sent
      referenceAudio_2?: string     // voice, as referenceAudio_1
      referenceAudio_3?: string     // voice, as referenceAudio_1
      count?: number                // 1-4
      captchaToken?: string         // your own captcha token, as sent
      captchaRetry?: number         // as requested
      captchaOrder?: string[]       // the captcha providers you named, in your order
      async?: boolean               // Fire-and-forget mode
      replyUrl?: string             // Webhook URL for callbacks
      replyRef?: string             // Custom reference for callbacks
    }
    
  • Image generation job structure. An image job is created until Google answers, then completed or failed.

    {
      jobid: string                       // Unique job identifier
      type: 'image'                       // Job type
      status: 'created' | 'completed' | 'failed'  // created: not yet answered by Google
      created: string                     // ISO 8601 creation timestamp
      updated?: string                    // ISO 8601 last update timestamp
    
      request: {                          // the request as you sent it, after validation
        email: string                     // the account that ran the job (picked for you when not given)
        prompt: string                    // your prompt
        model?: 'nano-banana-2-lite' | 'nano-banana-2' | 'nano-banana-pro' | 'imagen-4' | 'nano-banana'  // as requested ('imagen-4' and 'nano-banana' are deprecated aliases)
        aspectRatio?: '16:9' | '4:3' | '1:1' | '3:4' | '9:16' | 'auto' | 'landscape' | 'portrait'  // as requested ('landscape' and 'portrait' are legacy values)
        count?: number                    // 1-4
        seed?: number                     // as requested
        thinkingLevel?: 'low' | 'medium' | 'high'  // as requested
        reference_1?: Reference           // reference image (reference_1 to reference_10, as many as you sent)
        reference_2?: Reference           // reference image
        reference_3?: Reference           // reference image
        reference_4?: Reference           // reference image
        reference_5?: Reference           // reference image
        reference_6?: Reference           // reference image
        reference_7?: Reference           // reference image
        reference_8?: Reference           // reference image
        reference_9?: Reference           // reference image
        reference_10?: Reference          // reference image
        character_1?: Reference           // character (character_1 to character_7, as many as you sent)
        character_2?: Reference           // character
        character_3?: Reference           // character
        character_4?: Reference           // character
        character_5?: Reference           // character
        character_6?: Reference           // character
        character_7?: Reference           // character
        captchaToken?: string             // your own captcha token, as sent
        captchaRetry?: number             // as requested
        captchaOrder?: string[]           // the captcha providers you named, in your order
        replyUrl?: string                 // Webhook URL for callbacks
        replyRef?: string                 // Custom reference for callbacks
      }
    
      response?: {                        // the result, set once Google has answered
        media?: Array<{                   // one item per image generated
          name: string                    // media id (raw UUID)
          workflowId: string              // the Google Flow workflow of the image
          image: {                        // the image
            generatedImage: {             // Google's record of the generated image
              seed: number                // the seed Google used
              mediaGenerationId: string   // reference id for later calls (upscale, references)
              mediaVisibility: string     // always empty
              prompt: string              // the prompt as Google ran it
              modelNameType: string       // Google's model name, e.g. "BELUGA" (nano-banana-2)
              workflowId: string          // the Google Flow workflow of the image (same as above)
              fifeUrl: string             // Signed image URL (valid ~6h). Empty when Google gave none
              aspectRatio: string         // e.g. IMAGE_ASPECT_RATIO_LANDSCAPE
              requestData: {              // what Google recorded about the request
                promptInputs: Array<{     // the prompt
                  textInput: string       // your prompt
                }>
                imageGenerationRequestData: {  // Google's generation settings
                  backend: 'flow'         // the request went through `flow.google.com`
                  referencesApplied: {    // the references Google used
                    media: string[]       // media ids of the reference images
                    entities: string[]    // entity ids of the characters
                  }
                  aspectEnum: number | null  // Google's raw aspect value
                  modelEnum: number | null   // Google's raw model value
                }
              }
            }
            dimensions?: {                // the image size, when Google reports it
              width: number               // pixels
              height: number              // pixels
            }
          }
        }>
        captcha?: Captcha                 // the captcha solve of this job
        error?: string | GoogleError      // on a failed job, one of two: a string, what went wrong in the API's own words,
                                          // or GoogleError, Google's error as Google returned it
      }
    
      error?: string                      // Error message (if failed)
      code?: number                       // HTTP status code (if failed)
    }
    
  • Concatenation jobs. POST /videos/concatenate answers with the video itself. Its job record keeps only the outcome.

    {
      jobid: string                       // Unique job identifier
      type: 'video'                       // Job type
      status: 'created' | 'started' | 'completed' | 'failed'  // started: Google is joining the videos
      created: string                     // ISO 8601 creation timestamp
      updated?: string                    // ISO 8601 last update timestamp
    
      request: {                          // the request as you sent it, after validation
        email: string                     // the account of the videos
        media: Array<{                    // the videos, in order
          mediaGenerationId: Reference    // the video
          trimStart?: number              // seconds trimmed from the start, as requested
          trimEnd?: number                // seconds trimmed from the end, as requested
        }>
      }
    
      response?: {                        // set once Google has answered
        operationName?: string            // Google's job name, while the job is started
        status?: string                   // MEDIA_GENERATION_STATUS_SUCCESSFUL, once completed
        inputsCount?: number              // how many videos were joined, once completed
        hasEncodedVideo?: boolean         // true once completed (the video itself was in the POST answer)
        encodedVideoLength?: number       // length of that base64 video, once completed
        head?: Array<unknown>             // Google's raw answer, when Google failed the concatenation
        backend?: 'flow'                  // the request went through `flow.google.com`
        error?: string | GoogleError      // on a failed job, one of two: a string, what went wrong in the API's own words,
                                          // or GoogleError, Google's error as Google returned it
      }
    
      error?: string                      // Error message (if failed)
      code?: number                       // HTTP status code (if failed)
    }
    

A reference id you sent, decoded:

Reference: each image, character or video reference in a job’s request above, decoded.

{
  referenceId: string                 // the reference id as you sent it
  user: number                        // your useapi.net user number
  email: string                       // the account the media belongs to
  type: 'image' | 'video' | 'character' | 'voice'  // what it points to
  id: string                          // Google's id: the media id, or the character's entity id
  meta?: {                            // characters only
    imgs: number                      // how many images the character has
    voiceWorkflowId?: string          // the workflow of the character's voice, when it has one
  }
}

The captcha solve of a job:

Captcha: the captcha in a job’s response above.

{
  service?: string                    // the provider whose token was used: `CapSolver`, `AntiCaptcha`, `YesCaptcha`,
                                      // `CapMonster`, `SolveCaptcha`, `2Captcha`, `EzCaptcha` or `UserProvided`. Only when a
                                      // token was found
  taskId?: string                     // the provider's task id of the token used
  durationMs?: number                 // ms from the first attempt to the token. Only when a token was found
  error?: string                      // why no captcha could be solved. Only when the captcha failed
  attempts: Array<{                   // every provider tried, in order
    service: string                   // the provider
    success: boolean                  // true when the provider returned a token
    durationMs?: number               // how long this attempt took, ms
    taskId?: string                   // the provider's task id
    error?: string                    // why the provider failed
    userAgent?: string                // the browser the provider solved in
    secChUa?: string                  // that browser's Sec-CH-UA header
    cost?: string                     // the provider's price for this solve (AntiCaptcha, CapMonster, 2Captcha)
    ip?: string                       // the address the provider reports
    createTime?: number               // the provider's task start, Unix seconds
    endTime?: number                  // the provider's task end, Unix seconds
    solveCount?: number               // the provider's own counter
    request?: string                  // SolveCaptcha's raw answer
  }>
}

Google’s error, as Google returned it:

GoogleError: the error in a job’s response above, when it is Google’s own error.

{
  code: number                        // HTTP status, e.g. 429
  message: string                     // what failed, e.g. "flow.google.com ogiZ0b failed"
  status: string                      // e.g. RESOURCE_EXHAUSTED
  details?: Array<object>             // Google's reasons, a list of error details
}

Missing media URLs

Media URL fields are optional and can be absent even when generation succeeded. When videoUrl, thumbnailUrl, fifeUrl, servingBaseUri, previewUrl or audioUrl is missing, the media itself is fine — only the download link could not be produced at that moment.

This is rare. Across the seven days of request logs we keep, it happened on one day only — twice, for about four hours and about forty minutes — and not at all on the other six. Google issues those links from an endpoint that limits how often it will answer a given network address, so it is Google limiting our outbound calls rather than useapi.net limiting you, and nothing you do triggers it. While it lasts it affects every account generating at that moment, then clears on its own. Your generation still completed and was charged as usual.

On a media item that generated successfully — mediaStatus.mediaGenerationStatus is MEDIA_GENERATION_STATUS_SUCCESSFUL — a missing URL means “not yet”, not “failed”, so read the field before using it and treat its absence as a retry condition. A media item that failed generation never carries a URL, and retrying will not produce one.

const url = media.videoUrl;
if (!url) {
  // Not an error — the link is not available yet. See the options below.
}

Which route to use depends on whether you can wait.

If you are already polling the job, do nothing special. Completed video jobs re-resolve missing URLs automatically on GET /jobs/jobId, and the recovered link is saved, so a later poll returns it with no extra work on your side. This applies to video jobs created within the last 24 hours. Once the job is completed and a URL is still missing, leave at least a minute between polls — a job re-resolves at most once a minute, and the block clears only once traffic stops, so a tight retry loop lengthens the wait rather than shortening it.

If you hold a mediaGenerationId but no longer have the job, ask for that one media again with GET /assets/mediaGenerationId. That endpoint says which case you are in rather than leaving you to guess. A 503 with a Retry-After header means the link is coming and tells you how long to wait, so wait that long and ask again. A 404 means Google has no such media, and no amount of retrying will change it.

If you cannot wait, download the video through us with GET /assets/mediaGenerationId?raw=true. It reads the media over a different Google route that the block does not touch, so it works immediately and keeps working while the other two return nothing. It is video only.

Prefer the two link-based routes when you can. They hand you a link and you download straight from Google. The raw form moves the whole file through useapi.net on every call, which makes it a way out of a stuck download rather than your normal download path.

Characters and voices resolve their URLs as they are read, so simply requesting GET /characters/ref or GET /voices/ref again is enough. Wait a minute before retrying — a response that came back without its URL is held briefly, so an immediate repeat returns the same one.

None of this applies to images. Whenever an image URL is missing, POST /images puts the image itself in the response instead, base64-encoded in encodedImage — so you already have the picture and there is nothing to retry.

Examples

  • # Get job status
    curl "https://api.useapi.net/v1/google-flow/jobs/j1111190012345482913v-u12345-email:john@gmail.com-bot:google-flow" \
      -H "Authorization: Bearer {API token}"
    
    # Poll for completion (check every 5 seconds)
    while true; do
      STATUS=$(curl -s "https://api.useapi.net/v1/google-flow/jobs/j1111190012345482913v-u12345-email:john@gmail.com-bot:google-flow" \
        -H "Authorization: Bearer {API token}" | jq -r '.status')
    
      echo "Status: $STATUS"
    
      if [[ "$STATUS" == "completed" || "$STATUS" == "failed" ]]; then
        break
      fi
    
      sleep 5
    done
    
  • const apiToken = 'your-api-token'
    const jobId = 'j1111190012345482913v-u12345-email:john@gmail.com-bot:google-flow'
    
    // Get job status
    async function getJobStatus(jobId) {
      const response = await fetch(`https://api.useapi.net/v1/google-flow/jobs/${jobId}`, {
        headers: {
          'Authorization': `Bearer ${apiToken}`
        }
      })
    
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${await response.text()}`)
      }
    
      return await response.json()
    }
    
    // Poll until completion
    async function waitForCompletion(jobId, intervalMs = 5000) {
      while (true) {
        const job = await getJobStatus(jobId)
        console.log(`Status: ${job.status}`)
    
        if (job.status === 'completed') {
          console.log('Job completed!', job.response)
          return job
        }
    
        if (job.status === 'failed') {
          console.error('Job failed:', job.error)
          throw new Error(job.error)
        }
    
        await new Promise(resolve => setTimeout(resolve, intervalMs))
      }
    }
    
    // Usage
    const job = await waitForCompletion(jobId)
    
  • import requests
    import time
    
    api_token = 'your-api-token'
    job_id = 'j1111190012345482913v-u12345-email:john@gmail.com-bot:google-flow'
    
    # Get job status
    def get_job_status(job_id: str) -> dict:
        response = requests.get(
            f'https://api.useapi.net/v1/google-flow/jobs/{job_id}',
            headers={'Authorization': f'Bearer {api_token}'}
        )
        response.raise_for_status()
        return response.json()
    
    # Poll until completion
    def wait_for_completion(job_id: str, interval_sec: int = 5) -> dict:
        while True:
            job = get_job_status(job_id)
            print(f"Status: {job['status']}")
    
            if job['status'] == 'completed':
                print("Job completed!", job['response'])
                return job
    
            if job['status'] == 'failed':
                raise Exception(f"Job failed: {job.get('error')}")
    
            time.sleep(interval_sec)
    
    # Usage
    job = wait_for_completion(job_id)
    
    # Access video URLs (for video jobs)
    if job['type'] == 'video':
        for item in job['response']['media']:
            if 'videoUrl' in item:
                print(f"Video URL: {item['videoUrl']}")
    
    # Access image URLs (for image jobs)
    if job['type'] == 'image':
        for media in job['response']['media']:
            if 'image' in media and 'generatedImage' in media['image']:
                print(f"Image URL: {media['image']['generatedImage']['fifeUrl']}")
    

Try It