> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reap.video/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Project Status

> Check the current processing status of a video project

> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.

## Overview

Get the current processing status of a video project. This is a lightweight endpoint that returns essential status information for monitoring project progress without fetching full project details.

## Response

<ResponseField name="projectId" type="string">
  The unique identifier of the project
</ResponseField>

<ResponseField name="projectType" type="string">
  Type of project ("clipping", "captions", "reframe", "dubbing", or "transcription")
</ResponseField>

<ResponseField name="source" type="string">
  Source of the original video ("Youtube", "Upload", or "Generic")
</ResponseField>

<ResponseField name="status" type="string">
  Current processing status of the project
</ResponseField>

## Project Status Values

<ResponseField name="queued" type="status">
  Project is queued and waiting to be processed
</ResponseField>

<ResponseField name="processing" type="status">
  Project is currently being processed by our AI systems
</ResponseField>

<ResponseField name="completed" type="status">
  Project has finished processing successfully - clips are ready
</ResponseField>

<ResponseField name="failed" type="status">
  Project processing failed due to an error
</ResponseField>

<ResponseField name="cancelled" type="status">
  Project was cancelled before completion
</ResponseField>

## Project Type Values

<ResponseField name="clipping" type="project-type">
  AI-powered short clip generation from long-form videos
</ResponseField>

<ResponseField name="captions" type="project-type">
  Caption generation and styling for videos
</ResponseField>

<ResponseField name="reframe" type="project-type">
  Video reframing for different aspect ratios
</ResponseField>

<ResponseField name="dubbing" type="project-type">
  Voice dubbing and translation services
</ResponseField>

<ResponseField name="transcription" type="project-type">
  Audio transcription for videos
</ResponseField>

## Example Request

<CodeGroup>
  ```bash cURL theme={"system"}
  curl -X GET "https://public.reap.video/api/v1/automation/get-project-status?projectId=65f1a2b3c4d5e6f7a8b9c0d1" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json"
  ```

  ```javascript JavaScript theme={"system"}
  const projectId = '65f1a2b3c4d5e6f7a8b9c0d1';
  const response = await fetch(`https://public.reap.video/api/v1/automation/get-project-status?projectId=${projectId}`, {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    }
  });

  const status = await response.json();
  console.log('Project status:', status.status);
  ```

  ```python Python theme={"system"}
  import requests

  headers = {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
  }

  project_id = '65f1a2b3c4d5e6f7a8b9c0d1'
  response = requests.get(
      'https://public.reap.video/api/v1/automation/get-project-status',
      headers=headers,
      params={'projectId': project_id}
  )

  status = response.json()
  print(f"Project {status['projectId']} is {status['status']}")
  ```

  ```php PHP theme={"system"}
  <?php
  $projectId = '65f1a2b3c4d5e6f7a8b9c0d1';
  $url = 'https://public.reap.video/api/v1/automation/get-project-status?projectId=' . $projectId;
  $ch = curl_init($url);
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      'Authorization: Bearer YOUR_API_KEY',
      'Content-Type: application/json'
  ]);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  $response = curl_exec($ch);
  curl_close($ch);
  $status = json_decode($response, true);
  echo 'Project status: ' . $status['status'] . "\n";
  ?>
  ```

  ```go Go theme={"system"}
  package main
  import (
      "fmt"
      "io/ioutil"
      "net/http"
  )
  func main() {
      projectId := "65f1a2b3c4d5e6f7a8b9c0d1"
      url := "https://public.reap.video/api/v1/automation/get-project-status?projectId=" + projectId
      req, _ := http.NewRequest("GET", url, nil)
      req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
      req.Header.Set("Content-Type", "application/json")
      client := &http.Client{}
      resp, _ := client.Do(req)
      defer resp.Body.Close()
      body, _ := ioutil.ReadAll(resp.Body)
      fmt.Println(string(body))
  }
  ```

  ```java Java theme={"system"}
  import java.io.BufferedReader;
  import java.io.InputStreamReader;
  import java.net.HttpURLConnection;
  import java.net.URL;
  public class GetProjectStatusExample {
      public static void main(String[] args) throws Exception {
          String projectId = "65f1a2b3c4d5e6f7a8b9c0d1";
          URL url = new URL("https://public.reap.video/api/v1/automation/get-project-status?projectId=" + projectId);
          HttpURLConnection conn = (HttpURLConnection) url.openConnection();
          conn.setRequestMethod("GET");
          conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
          conn.setRequestProperty("Content-Type", "application/json");
          BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
          StringBuilder response = new StringBuilder();
          String line;
          while ((line = br.readLine()) != null) {
              response.append(line);
          }
          br.close();
          System.out.println(response.toString());
      }
  }
  ```
</CodeGroup>

## Example Response

<CodeGroup>
  <CodeGroup.Tab label="200 OK">
    ```json theme={"system"}
    {
      "projectId": "65f1a2b3c4d5e6f7a8b9c0d1",
      "projectType": "clipping",
      "source": "Upload",
      "status": "processing"
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="404 Not Found">
    ```json theme={"system"}
    {
      "detail": "Project not found"
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="401 Unauthorized">
    ```json theme={"system"}
    {
      "detail": "Unauthorized - Invalid or missing API key"
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="429 Too Many Requests">
    ```json theme={"system"}
    {
      "detail": "Too Many Requests - Rate limit exceeded"
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="500 Internal Server Error">
    ```json theme={"system"}
    {
      "detail": "Internal Server Error - Something went wrong on our end"
    }
    ```
  </CodeGroup.Tab>
</CodeGroup>

## Polling Example

<Tip>
  **Prefer webhooks over polling.** Set up [webhooks](/api-reference/webhooks) to get notified automatically when projects reach a final state, instead of polling this endpoint in a loop.
</Tip>

For cases where polling is needed, use a separate polling loop that calls this endpoint at regular intervals:

```javascript theme={"system"}
async function waitForCompletion(projectId) {
  const pollInterval = 5000; // 5 seconds
  
  while (true) {
    const response = await fetch(`https://public.reap.video/api/v1/automation/get-project-status?projectId=${projectId}`, {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      }
    });
    
    const status = await response.json();
    
    if (status.status === 'completed') {
      console.log('Project completed successfully!');
      break;
    } else if (status.status === 'failed') {
      console.log('Project failed');
      break;
    }
    
    console.log('Still processing...');
    await new Promise(resolve => setTimeout(resolve, pollInterval));
  }
}
```

## Processing Times

Typical processing times by project type:

<CardGroup cols={2}>
  <Card title="Clipping Projects" icon="scissors">
    **5-15 minutes** depending on video length and complexity
  </Card>

  <Card title="Caption Projects" icon="closed-captioning">
    **2-5 minutes** for most video lengths
  </Card>

  <Card title="Reframe Projects" icon="expand">
    **3-8 minutes** depending on video length
  </Card>

  <Card title="Dubbing Projects" icon="microphone">
    **10-20 minutes** depending on video length and language pair
  </Card>
</CardGroup>

## Rate Limiting

This endpoint is subject to the standard rate limit of **10 requests per minute**.

## Best Practices

<Tip>
  **Polling Guidelines:**

  * Poll every 5-10 seconds for active monitoring
  * Use exponential backoff for long-running projects
  * Handle rate limits gracefully in your polling logic
  * Consider using [webhooks](/api-reference/webhooks) for production applications instead of polling
</Tip>

## Common Use Cases

<CardGroup cols={2}>
  <Card title="Progress Monitoring" icon="chart-line">
    Track project progress in real-time user interfaces
  </Card>

  <Card title="Automated Workflows" icon="robot">
    Build automated systems that wait for project completion
  </Card>

  <Card title="Status Dashboards" icon="dashboard">
    Create monitoring dashboards for multiple projects
  </Card>

  <Card title="Error Handling" icon="exclamation-triangle">
    Detect and handle failed projects in your applications
  </Card>
</CardGroup>

## Next Steps

Based on the project status:

* **Processing**: Continue monitoring or check [Get Project Details](/api-reference/get-project-details)
* **Completed**: Retrieve results with [Get Project Clips](/api-reference/get-project-clips)
* **Failed**: Review project details and retry if needed


## OpenAPI

````yaml GET /automation/get-project-status
openapi: 3.1.0
info:
  title: Reap Automation API
  description: AI-powered video processing automation API
  version: 1.0.0
servers:
  - url: https://public.reap.video/api/v1
security:
  - bearerAuth: []
paths:
  /automation/get-project-status:
    get:
      summary: Get Project Status
      description: Check the current processing status of a video project
      operationId: getProjectStatus
      parameters:
        - $ref: '#/components/parameters/projectId'
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProjectStatusResponse'
components:
  parameters:
    projectId:
      name: projectId
      in: query
      required: true
      schema:
        type: string
      description: Unique identifier of the project
  schemas:
    ProjectStatusResponse:
      type: object
      properties:
        projectId:
          type: string
        projectType:
          type: string
          enum:
            - clipping
            - captions
            - reframe
            - dubbing
            - transcription
        source:
          type: string
          enum:
            - Upload
            - Youtube
            - Vimeo
            - TwitchVod
            - Twitter
            - RumbleEmbed
            - Generic
        status:
          type: string
          enum:
            - queued
            - prepped
            - draft
            - processing
            - finalizing
            - completed
            - invalid
            - expired
            - failed
            - error
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````