GET jobs/jobid

Retrieve Job Status

November 17, 2025

Request Headers
Path Parameters
Responses
Model
Examples
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.

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

Request Headers

Authorization: Bearer {API token}

API token is required, see Setup useapi.net for details.

Path Parameters

jobId is required, the unique job identifier returned from POST /images or POST /videos.

Responses

200 OK

Returns the job record with current status and details.

Video job (completed):

{
  "jobid": "j1731859234567v-u12345-email:jo***@gmail.com-bot:google-flow",
  "type": "video",
  "status": "completed",
  "created": "2025-11-17T12:34:56.789Z",
  "updated": "2025-11-17T12:37:23.456Z",
  "request": {
    "email": "jo***@gmail.com",
    "prompt": "A serene mountain landscape at sunset with camera slowly panning right",
    "model": "veo-3.1-fast",
    "aspectRatio": "landscape",
    "count": 2,
    "seed": 123456,
    "async": true,
    "replyUrl": "https://your-domain.com/webhook"
  },
  "response": {
    "operations": [
      {
        "operation": {
          "name": "d00af...redacted...6f7a"
        },
        "sceneId": "abc123...",
        "status": "VIDEO_GENERATION_STATUS_SUCCEEDED",
        "video": {
          "uri": "https://storage.googleapis.com/...",
          "seed": 123456,
          "mediaGenerationId": "CAUSJ...redacted...OWQ5ZA",
          "fifeUrl": "https://storage.googleapis.com/...",
          "servingBaseUri": "https://lh3.googleusercontent.com/..."
        }
      }
    ]
  }
}

Image job (completed):

{
  "jobid": "j1731859345678i-u12345-email:an***@gmail.com-bot:google-flow",
  "type": "image",
  "status": "completed",
  "created": "2025-11-17T12:45:12.345Z",
  "updated": "2025-11-17T12:45:34.678Z",
  "request": {
    "email": "an***@gmail.com",
    "prompt": "A serene mountain landscape at sunset with vibrant colors",
    "model": "imagen-4",
    "aspectRatio": "landscape",
    "count": 4,
    "replyUrl": "https://your-domain.com/webhook",
    "replyRef": "custom-reference-123"
  },
  "response": {
    "media": [
      {
        "name": "…redacted…",
        "image": {
          "generatedImage": {
            "seed": 987654,
            "mediaGenerationId": "user:12345…redacted…",
            "fifeUrl": "https://storage.googleapis.com/...",
            "prompt": "A serene mountain landscape at sunset with vibrant colors"
          }
        }
      }
    ]
  }
}

Job failed:

{
  "jobid": "j1731859567890i-u12345-email:an***@gmail.com-bot:google-flow",
  "type": "image",
  "status": "failed",
  "created": "2025-11-17T13:00:12.345Z",
  "updated": "2025-11-17T13:00:45.678Z",
  "request": {
    "email": "an***@gmail.com",
    "prompt": "Generate an image",
    "model": "nano-banana"
  },
  "error": "API error: 500",
  "code": 500,
  "response": {
    "error": {
      "code": 500,
      "message": "Internal error encountered.",
      "status": "INTERNAL"
    }
  }
}

400 Bad Request

Invalid job ID format.
```
{
  "error": "Invalid job ID format"
}
```
401 Unauthorized

Invalid API token.
```
{
  "error": "Unauthorized"
}
```

403 Forbidden

Job belongs to a different user.

{
  "error": "Access denied - job belongs to different user"
}

404 Not Found

Job not found in database.
```
{
  "error": "Job not found"
}
```
410 Gone

Job has expired (jobs are retained for 31 days).
```
{
  "error": "Job has expired"
}
```

Model

Video generation job structure.

{
  jobid: string                       // Unique job identifier
  type: 'video'                       // Job type
  status: 'created' | 'started' | 'completed' | 'failed'
  created: string                     // ISO 8601 creation timestamp
  updated?: string                    // ISO 8601 last update timestamp

  request: {
    email?: string
    prompt: string
    model?: 'veo-3.1-quality' | 'veo-3.1-fast'
    aspectRatio?: 'landscape' | 'portrait' | 'square'
    count?: number                    // 1-4
    seed?: number
    startImage?: string               // mediaGenerationId for I2V mode
    endImage?: string                 // mediaGenerationId for I2V-FL mode
    referenceImage_1?: string         // mediaGenerationId for R2V mode
    referenceImage_2?: string         // mediaGenerationId for R2V mode
    referenceImage_3?: string         // mediaGenerationId for R2V mode
    async?: boolean                   // Fire-and-forget mode
    replyUrl?: string                 // Webhook URL for callbacks
    replyRef?: string                 // Custom reference for callbacks
  }

  response?: {
    operations: Array<{
      operation: {
        name: string
        metadata?: {                  // Present when completed
          '@type': string
          name: string
          video: {
            seed: number
            mediaGenerationId: string
            prompt: string
            fifeUrl: string           // Signed video URL (MP4, valid ~24h)
            mediaVisibility: string
            servingBaseUri: string    // Signed thumbnail URL (JPEG, valid ~24h)
            model: string             // veo_3_1_t2v | veo_3_1_i2v | veo_3_1_i2v_fl | veo_3_0_r2v
            isLooped: boolean
            aspectRatio: string       // VIDEO_ASPECT_RATIO_LANDSCAPE | PORTRAIT
          }
        }
      }
      sceneId: string
      mediaGenerationId?: string      // Present when completed
      status: string                  // MEDIA_GENERATION_STATUS_PENDING | PROCESSING | SUCCESSFUL | FAILED
    }>
    remainingCredits?: number
  }

  error?: string                      // Error message (if failed)
  errorDetails?: string               // Additional error details
  code?: number                       // HTTP status code (if failed)
}

Image generation job structure.

{
  jobid: string                       // Unique job identifier
  type: 'image'                       // Job type
  status: 'created' | 'started' | 'completed' | 'failed'
  created: string                     // ISO 8601 creation timestamp
  updated?: string                    // ISO 8601 last update timestamp

  request: {
    email?: string
    prompt: string
    model?: 'imagen-4' | 'nano-banana'
    aspectRatio?: 'landscape' | 'portrait'
    count?: number                    // 1-4
    seed?: number
    reference_1?: string              // mediaGenerationId
    reference_2?: string              // mediaGenerationId
    reference_3?: string              // mediaGenerationId
    replyUrl?: string                 // Webhook URL for callbacks
    replyRef?: string                 // Custom reference for callbacks
  }

  response?: {
    media: Array<{
      name: string
      image: {
        generatedImage: {
          seed: number
          mediaGenerationId: string
          fifeUrl: string             // Signed image URL (valid ~24h)
          prompt: string
        }
      }
    }>
  }

  error?: string                      // Error message (if failed)
  errorDetails?: string               // Additional error details
  code?: number                       // HTTP status code (if failed)
}

Examples

# Get job status
curl "https://api.useapi.net/v1/google-flow/jobs/j1731859234567v-u12345-email:jo***@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/j1731859234567v-u12345-email:jo***@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 = 'j1731859234567v-u12345-email:jo***@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 = 'j1731859234567v-u12345-email:jo***@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 op in job['response']['operations']:
        if 'video' in op and 'fifeUrl' in op['video']:
            print(f"Video URL: {op['video']['fifeUrl']}")

# 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']}")