GET jobs/jobid

Retrieve Job Status

January 21, 2026

Request Headers
Path Parameters
Responses
Model
Examples
Try It

Retrieve the status and details of a specific music or speech generation job by its job ID.

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

Job IDs are returned from:

Jobs are retained for 7 days after creation. Jobs older than 7 days will return a 404 error.

To get a summary of all running jobs, use GET /jobs.

https://api.useapi.net/v1/mureka/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.

Responses

200 OK

Returns the job record with current status and details.

Music job (completed):

{
    "jobid": "j0121061432017475905m-u777-a12345678901234-bot:mureka",
    "verb": "music/create",
    "jobType": "music",
    "status": "completed",
    "created": "2026-01-20T12:34:56.789Z",
    "updated": "2026-01-20T12:35:42.123Z",
    "request": {
        "account": "12345678901234",
        "prompt": "Upbeat electronic dance track",
        "model": "V7.6",
        "async": true,
        "replyUrl": "https://your-domain.com/webhook",
        "replyRef": "my-custom-ref-123"
    },
    "response": {
        "feed_id": 11223344,
        "state": 3,
        "songs": [
            {
                "song_id": "user:777-mureka:123456789-song:33445566",
                "title": "Upbeat Dance",
                "version": "1",
                "duration_milliseconds": 234567,
                "mp3_url": "https://...mp3",
                "cover": "https://...png"
            },
            {
                "song_id": "user:777-mureka:123456789-song:33445567",
                "title": "Upbeat Dance",
                "version": "2",
                "duration_milliseconds": 234890,
                "mp3_url": "https://...mp3",
                "cover": "https://...png"
            }
        ]
    }
}

Speech job (completed):

{
    "jobid": "j0121061456745673364t-u777-a12345678901234-bot:mureka",
    "verb": "speech",
    "jobType": "tts",
    "status": "completed",
    "created": "2026-01-20T12:40:00.000Z",
    "updated": "2026-01-20T12:40:25.000Z",
    "request": {
        "account": "12345678901234",
        "text": "Hello, this is a test speech.",
        "voice_id": 12345,
        "async": true
    },
    "response": {
        "title": "Hello, this is a test speech.",
        "mp3_url": "https://...mp3",
        "duration_milliseconds": 5000,
        "state": 3
    }
}

Job still processing:

{
    "jobid": "j0121061432017475905m-u777-a12345678901234-bot:mureka",
    "verb": "music/create",
    "jobType": "music",
    "status": "created",
    "created": "2026-01-20T12:34:56.789Z",
    "request": {
        "account": "12345678901234",
        "prompt": "Upbeat electronic dance track",
        "async": true
    }
}

Job failed:

{
    "jobid": "j0121061432017475905m-u777-a12345678901234-bot:mureka",
    "verb": "music/create",
    "jobType": "music",
    "status": "failed",
    "created": "2026-01-20T12:34:56.789Z",
    "updated": "2026-01-20T12:35:10.000Z",
    "request": {
        "account": "12345678901234",
        "prompt": "Test prompt",
        "async": true
    },
    "error": "Content policy violation",
    "code": 400
}

400 Bad Request

Invalid job ID format.

{
  "error": "Invalid job ID: Missing required component"
}

401 Unauthorized

Invalid API token.

{
  "error": "Unauthorized",
  "code": 401
}

403 Forbidden

Job belongs to a different user.

{
  "error": "Unauthorized access to job"
}

404 Not Found

Job not found or has expired (jobs are retained for 7 days).
```
{
  "error": "Job not found"
}
```

Model

Music generation job structure.

{
  jobid: string                              // Unique job identifier
  verb: 'music/create' | 'music/create-instrumental' | 'music/create-advanced' | 'music/regenerate' | 'music/extend'
  jobType: 'music'                           // Job type
  status: 'created' | 'completed' | 'failed'
  created: string                            // ISO 8601 creation timestamp
  updated?: string                           // ISO 8601 last update timestamp

  request: {
    account?: string                         // Mureka account ID
    prompt?: string                          // Text prompt (for create endpoints)
    title?: string                           // Song title
    lyrics?: string                          // Lyrics (for create-advanced, extend)
    song_id?: string                         // Source song ID (for extend, regenerate)
    start_milliseconds?: number              // Start position (for regenerate)
    model?: string                           // AI model used
    instrumental_model?: string              // Instrumental model (for create-instrumental)
    ref_id?: string                          // Reference track ID
    vocal_id?: string                        // Vocal library ID
    motif_id?: string                        // Motif ID
    mood?: string                            // Mood tag
    genre?: string                           // Genre tag
    vocal_gender?: string                    // Vocal gender (male, female)
    async?: boolean                          // Fire-and-forget mode
    replyUrl?: string                        // Webhook URL for callbacks
    replyRef?: string                        // Custom reference for callbacks
  }

  response?: {                               // Present when completed
    feed_id: number
    state: number
    songs: Array<{
      song_id: string
      title: string
      version: string
      duration_milliseconds: number
      generate_at: number
      genres: string[]
      moods: string[]
      mp3_url: string
      share_key: string
      cover: string
      share_link: string
    }>
  }

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

Speech generation job structure.

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

  request: {
    account?: string                         // Mureka account ID
    title?: string                           // Speech title
    text?: string                            // Text to convert to speech
    voice_id?: number                        // Voice ID
    conversation?: Array<{voice_id: number, text: string}>  // Multi-speaker conversation
    async?: boolean                          // Fire-and-forget mode
    replyUrl?: string                        // Webhook URL for callbacks
    replyRef?: string                        // Custom reference for callbacks
  }

  response?: {                               // Present when completed
    title: string
    preview: string
    cover: string
    mp3_url: string
    id: number
    duration_milliseconds: number
    audio_quality: number
    state: number
  }

  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/mureka/jobs/j0121061432017475905m-u777-a12345678901234-bot:mureka" \
  -H "Authorization: Bearer {API token}"

# Poll for completion (check every 5 seconds)
while true; do
  STATUS=$(curl -s "https://api.useapi.net/v1/mureka/jobs/j0121061432017475905m-u777-a12345678901234-bot:mureka" \
    -H "Authorization: Bearer {API token}" | jq -r '.status')

  echo "Status: $STATUS"

  if [[ "$STATUS" == "completed" || "$STATUS" == "failed" ]]; then
    break
  fi

  sleep 5
done

const token = "API token";
const jobid = "j0121061432017475905m-u777-a12345678901234-bot:mureka";

// Get job status
async function getJobStatus(jobid) {
  const response = await fetch(`https://api.useapi.net/v1/mureka/jobs/${jobid}`, {
    headers: {
      "Authorization": `Bearer ${token}`
    }
  });

  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);

// Access song URLs (for music jobs)
if (job.jobType === "music" && job.response?.songs) {
  job.response.songs.forEach((song, i) => {
    console.log(`Song ${i + 1}: ${song.mp3_url}`);
  });
}

// Access audio URL (for speech jobs)
if (job.jobType === "tts" && job.response?.mp3_url) {
  console.log(`Speech audio: ${job.response.mp3_url}`);
}

import requests
import time

token = "API token"
jobid = "j0121061432017475905m-u777-a12345678901234-bot:mureka"

# Get job status
def get_job_status(jobid: str) -> dict:
    response = requests.get(
        f"https://api.useapi.net/v1/mureka/jobs/{jobid}",
        headers={"Authorization": f"Bearer {token}"}
    )
    response.raise_for_status()
    return response.json()

# Poll until completion
def wait_for_completion(jobid: str, interval_sec: int = 5) -> dict:
    while True:
        job = get_job_status(jobid)
        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(jobid)

# Access song URLs (for music jobs)
if job["jobType"] == "music" and job.get("response", {}).get("songs"):
    for i, song in enumerate(job["response"]["songs"]):
        print(f"Song {i + 1}: {song['mp3_url']}")

# Access audio URL (for speech jobs)
if job["jobType"] == "tts" and job.get("response", {}).get("mp3_url"):
    print(f"Speech audio: {job['response']['mp3_url']}")