> ## 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 All Projects

> Retrieve all automation projects in your studio

> **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 a paginated list of all video projects created through the automation API. Monitor project status and access project details.

## Rate Limiting

This endpoint is rate limited to 10 requests per minute per API key.

## Filtering & Search

Use query parameters to filter, search, and sort the results.

<ParamField query="projectType" type="string[]" optional>
  Filter by project type. Pass multiple values to match any of them.

  * `clipping` - AI clip generation
  * `captions` - Caption generation
  * `reframe` - Video reframing
  * `dubbing` - Voice dubbing
  * `transcription` - Audio transcription
</ParamField>

<ParamField query="status" type="string[]" optional>
  Filter by processing status. Pass multiple values to match any of them.

  * `queued` - Waiting to be processed
  * `processing` - Currently being processed
  * `completed` - Processing finished successfully
  * `failed` - Processing failed
  * `invalid` - Video file was invalid
  * `expired` - Project has expired
</ParamField>

<ParamField query="search" type="string" optional>
  Search projects by title. Case-insensitive partial match.
</ParamField>

<ParamField query="createdAfter" type="integer" optional>
  Unix timestamp. Only return projects created after this time.
</ParamField>

<ParamField query="createdBefore" type="integer" optional>
  Unix timestamp. Only return projects created before this time.
</ParamField>

<ParamField query="sortBy" type="string" optional default="createdAt">
  Field to sort by.

  * `createdAt` - Sort by creation date
  * `updatedAt` - Sort by last update date
  * `duration` - Sort by billed duration
</ParamField>

<ParamField query="sortOrder" type="string" optional default="desc">
  Sort direction.

  * `asc` - Ascending (oldest/shortest first)
  * `desc` - Descending (newest/longest first)
</ParamField>

## Response

<ResponseField name="projects" type="array">
  Array of project objects

  <Expandable title="Project Object">
    <ResponseField name="id" type="string">
      Unique project identifier
    </ResponseField>

    <ResponseField name="title" type="string">
      Project title (usually the filename)
    </ResponseField>

    <ResponseField name="thumbnail" type="string">
      Thumbnail URL for the project
    </ResponseField>

    <ResponseField name="billedDuration" type="number">
      Duration in seconds that was billed for this project
    </ResponseField>

    <ResponseField name="status" type="string">
      Current processing status

      * `processing` - Project is being processed
      * `completed` - Processing completed successfully
      * `failed` - Processing failed
    </ResponseField>

    <ResponseField name="projectType" type="string">
      Type of project

      * `clipping` - AI clip generation
      * `captions` - Caption generation
      * `reframe` - Video reframing
      * `dubbing` - Voice dubbing
      * `transcription` - Audio transcription
    </ResponseField>

    <ResponseField name="source" type="string">
      Source of the video content

      * `Upload` - Uploaded file
      * `Youtube` - YouTube URL
    </ResponseField>

    <ResponseField name="genre" type="string">
      Video genre used for AI analysis
    </ResponseField>

    <ResponseField name="topics" type="array">
      Array of identified topics in the video
    </ResponseField>

    <ResponseField name="clipDurations" type="array">
      Array of clip duration preferences
    </ResponseField>

    <ResponseField name="selectedStart" type="number">
      Start time in seconds for processing (null if entire video)
    </ResponseField>

    <ResponseField name="selectedEnd" type="number">
      End time in seconds for processing (null if entire video)
    </ResponseField>

    <ResponseField name="exportResolution" type="integer">
      Output resolution for the project
    </ResponseField>

    <ResponseField name="exportOrientation" type="string">
      Output orientation
    </ResponseField>

    <ResponseField name="captionsPreset" type="string">
      Caption style preset ID (null if captions disabled)
    </ResponseField>

    <ResponseField name="enableCaptions" type="boolean">
      Whether captions are enabled
    </ResponseField>

    <ResponseField name="enableEmojis" type="boolean">
      Whether emojis are added to captions
    </ResponseField>

    <ResponseField name="enableHighlights" type="boolean">
      Whether keyword highlighting is enabled
    </ResponseField>

    <ResponseField name="language" type="string">
      Primary language of the video content
    </ResponseField>

    <ResponseField name="dubbingLanguage" type="string">
      Target dubbing language (null if not applicable)
    </ResponseField>

    <ResponseField name="translateTranscription" type="boolean">
      Whether transcription is translated
    </ResponseField>

    <ResponseField name="translationLanguages" type="array">
      Array of languages for translation
    </ResponseField>

    <ResponseField name="transcriptionScript" type="string">
      Script format for transcription ("native" or "roman")
    </ResponseField>

    <ResponseField name="metadata" type="object">
      Video file metadata including duration, resolution, format, etc.
    </ResponseField>

    <ResponseField name="urls" type="object">
      Project URLs and assets (populated when processing completes)
    </ResponseField>

    <ResponseField name="createdAt" type="integer">
      Unix timestamp when the project was created
    </ResponseField>

    <ResponseField name="updatedAt" type="integer">
      Unix timestamp when the project was last updated
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="currentPage" type="integer">
  Current page number
</ResponseField>

<ResponseField name="totalPages" type="integer">
  Total number of pages
</ResponseField>

<ResponseField name="totalProjects" type="integer">
  Total number of projects
</ResponseField>

## Example Request

<CodeGroup>
  ```bash cURL theme={"system"}
  curl -X GET "https://public.reap.video/api/v1/automation/get-all-projects?page=1&pageSize=20&projectType=clipping&status=completed&sortBy=createdAt&sortOrder=desc" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json"
  ```

  ```javascript JavaScript theme={"system"}
  const params = new URLSearchParams({
    page: '1',
    pageSize: '20',
    projectType: 'clipping',
    status: 'completed',
    sortBy: 'createdAt',
    sortOrder: 'desc'
  });

  const response = await fetch(`https://public.reap.video/api/v1/automation/get-all-projects?${params}`, {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    }
  });

  const data = await response.json();
  console.log(`Found ${data.totalProjects} projects`);
  ```

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

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

  params = {
      'page': 1,
      'pageSize': 20,
      'projectType': 'clipping',
      'status': 'completed',
      'sortBy': 'createdAt',
      'sortOrder': 'desc'
  }

  response = requests.get(
      'https://public.reap.video/api/v1/automation/get-all-projects',
      headers=headers,
      params=params
  )

  data = response.json()
  print(f"Found {data['totalProjects']} projects")
  ```

  ```php PHP theme={"system"}
  <?php
  $params = http_build_query([
      'page' => 1,
      'pageSize' => 20,
      'projectType' => 'clipping',
      'status' => 'completed',
      'sortBy' => 'createdAt',
      'sortOrder' => 'desc'
  ]);
  $ch = curl_init('https://public.reap.video/api/v1/automation/get-all-projects?' . $params);
  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);
  $data = json_decode($response, true);
  echo 'Found ' . $data['totalProjects'] . ' projects' . "\n";
  ?>
  ```

  ```go Go theme={"system"}
  package main
  import (
      "fmt"
      "io/ioutil"
      "net/http"
  )
  func main() {
      url := "https://public.reap.video/api/v1/automation/get-all-projects?page=1&pageSize=20&projectType=clipping&status=completed&sortBy=createdAt&sortOrder=desc"
      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.*;
  import java.net.HttpURLConnection;
  import java.net.URL;
  public class GetAllProjectsExample {
      public static void main(String[] args) throws Exception {
          URL url = new URL("https://public.reap.video/api/v1/automation/get-all-projects?page=1&pageSize=20&projectType=clipping&status=completed&sortBy=createdAt&sortOrder=desc");
          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(), "utf-8"));
          StringBuilder response = new StringBuilder();
          String responseLine;
          while ((responseLine = br.readLine()) != null) {
              response.append(responseLine.trim());
          }
          System.out.println("Found projects: " + response.toString());
      }
  }
  ```
</CodeGroup>

## Example Response

<CodeGroup>
  <CodeGroup.Tab label="200 OK">
    ```json theme={"system"}
    {
      "projects": [
        {
          "id": "65f1a2b3c4d5e6f7a8b9c0d2",
          "title": "My Educational Video",
          "thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d2.jpg",
          "billedDuration": 1800.5,
          "status": "completed",
          "projectType": "clipping",
          "source": "Upload",
          "genre": "talking",
          "topics": ["AI", "Technology", "Education"],
          "clipDurations": [],
          "selectedStart": 0,
          "selectedEnd": null,
          "exportResolution": 1080,
          "exportOrientation": "portrait",
          "captionsPreset": "system_beasty",
          "enableCaptions": true,
          "enableEmojis": true,
          "enableHighlights": true,
          "language": "en",
          "dubbingLanguage": null,
          "translateTranscription": false,
          "translationLanguages": [],
          "transcriptionScript": "native",
          "metadata": {
            "duration": 1800.5,
            "width": 1920,
            "height": 1080,
            "fps": 30,
            "bitrate": 5000000,
            "size": 450000000,
            "codec": "h264"
          },
          "urls": {
            "projectUrl": "https://app.reap.video/project/65f1a2b3c4d5e6f7a8b9c0d2",
            "downloadUrl": "https://cdn.reap.video/downloads/65f1a2b3c4d5e6f7a8b9c0d2.zip"
          },
          "createdAt": 1710000000,
          "updatedAt": 1710001800
        },
        {
          "id": "65f1a2b3c4d5e6f7a8b9c0d3",
          "title": "Marketing Webinar",
          "thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d3.jpg",
          "billedDuration": 3600.0,
          "status": "processing",
          "projectType": "clipping",
          "source": "Youtube",
          "genre": "talking",
          "topics": [],
          "clipDurations": [],
          "selectedStart": 300,
          "selectedEnd": 3300,
          "exportResolution": 720,
          "exportOrientation": "landscape",
          "captionsPreset": "system_minimal",
          "enableCaptions": true,
          "enableEmojis": false,
          "enableHighlights": false,
          "language": "en",
          "dubbingLanguage": null,
          "translateTranscription": false,
          "translationLanguages": [],
          "transcriptionScript": "native",
          "metadata": {
            "duration": 3600.0,
            "width": 1920,
            "height": 1080,
            "fps": 30,
            "bitrate": 3000000,
            "size": 800000000,
            "codec": "h264"
          },
          "urls": {},
          "createdAt": 1710002000,
          "updatedAt": 1710002000
        }
      ],
      "currentPage": 1,
      "totalPages": 5,
      "totalProjects": 87
    }
    ```
  </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 of 10 requests per minute 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>

## Project Status Values

* **`queued`** - Project is queued and waiting to be processed
* **`processing`** - Project is currently being processed (video analysis, clip generation, etc.)
* **`completed`** - All processing has finished successfully, clips are ready
* **`failed`** - Processing failed due to an error
* **`invalid`** - Video file was invalid or unsupported
* **`expired`** - Project has expired

## Project Types

* **`clipping`** - AI-powered clip generation from long-form videos
* **`captions`** - Caption and subtitle generation
* **`reframe`** - Automatic video reframing for different aspect ratios
* **`dubbing`** - Voice dubbing and translation
* **`transcription`** - Audio transcription

## Use Cases

<CardGroup cols={2}>
  <Card title="Dashboard Creation" icon="dashboard">
    Build project management dashboards
  </Card>

  <Card title="Batch Processing" icon="cubes">
    Monitor multiple projects simultaneously
  </Card>

  <Card title="Analytics" icon="chart-bar">
    Track processing patterns and success rates
  </Card>

  <Card title="Content Management" icon="folder">
    Organize and categorize video projects
  </Card>
</CardGroup>


## OpenAPI

````yaml GET /automation/get-all-projects
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-all-projects:
    get:
      summary: Get All Projects
      description: Retrieve all automation projects in your studio
      operationId: getAllProjects
      parameters:
        - $ref: '#/components/parameters/page'
        - name: pageSize
          in: query
          schema:
            type: integer
            default: 10
          description: Number of projects per page (max 100)
        - name: projectType
          in: query
          schema:
            type: array
            items:
              type: string
              enum:
                - clipping
                - captions
                - reframe
                - dubbing
                - transcription
          description: Filter by project type
        - name: status
          in: query
          schema:
            type: array
            items:
              type: string
              enum:
                - queued
                - prepped
                - draft
                - processing
                - finalizing
                - completed
                - invalid
                - expired
                - failed
                - error
          description: Filter by project status
        - name: search
          in: query
          schema:
            type: string
          description: Search projects by title
        - name: createdAfter
          in: query
          schema:
            type: integer
          description: Filter projects created after this Unix timestamp
        - name: createdBefore
          in: query
          schema:
            type: integer
          description: Filter projects created before this Unix timestamp
        - name: sortBy
          in: query
          schema:
            type: string
            enum:
              - createdAt
              - updatedAt
              - duration
            default: createdAt
          description: Sort field
        - name: sortOrder
          in: query
          schema:
            type: string
            enum:
              - asc
              - desc
            default: desc
          description: Sort direction
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetProjectsResponse'
components:
  parameters:
    page:
      name: page
      in: query
      schema:
        type: integer
        default: 1
      description: Page number for pagination
  schemas:
    GetProjectsResponse:
      type: object
      properties:
        projects:
          type: array
          items:
            $ref: '#/components/schemas/AutomationProject'
        currentPage:
          type: integer
        totalPages:
          type: integer
        totalProjects:
          type: integer
    AutomationProject:
      type: object
      properties:
        id:
          type: string
        title:
          type: string
        thumbnail:
          type: string
        billedDuration:
          type: number
        status:
          type: string
          enum:
            - queued
            - prepped
            - draft
            - processing
            - finalizing
            - completed
            - invalid
            - expired
            - failed
            - error
        projectType:
          type: string
          enum:
            - clipping
            - captions
            - reframe
            - dubbing
            - transcription
        source:
          type: string
          enum:
            - Upload
            - Youtube
            - Vimeo
            - TwitchVod
            - Twitter
            - RumbleEmbed
            - Generic
        genre:
          $ref: '#/components/schemas/VideoGenre'
        topics:
          type: array
          items:
            type: string
        clipDurations:
          type: array
          items:
            type: array
            items:
              type: integer
        selectedStart:
          type: number
          nullable: true
        selectedEnd:
          type: number
          nullable: true
        exportResolution:
          type: integer
        exportOrientation:
          $ref: '#/components/schemas/VideoOrientation'
        captionsPreset:
          type: string
          nullable: true
        enableCaptions:
          type: boolean
        enableEmojis:
          type: boolean
        enableHighlights:
          type: boolean
        language:
          type: string
          nullable: true
        dubbingLanguage:
          type: string
          nullable: true
        translateTranscription:
          type: boolean
        translationLanguages:
          type: array
          items:
            type: string
        transcriptionScript:
          $ref: '#/components/schemas/TranscriptionScript'
        metadata:
          $ref: '#/components/schemas/VideoFileMeta'
        urls:
          $ref: '#/components/schemas/ProjectUrls'
        createdAt:
          type: integer
        updatedAt:
          type: integer
    VideoGenre:
      type: string
      enum:
        - talking
        - screenshare
        - gaming
      default: talking
    VideoOrientation:
      type: string
      enum:
        - landscape
        - portrait
        - square
    TranscriptionScript:
      type: string
      enum:
        - native
        - roman
      default: native
    VideoFileMeta:
      type: object
      properties:
        width:
          type: integer
        height:
          type: integer
        aspectRatio:
          type: string
        size:
          type: number
        bitrate:
          type: number
        fps:
          type: number
        duration:
          type: number
        rotation:
          type: integer
        resolution:
          type: integer
        codec:
          type: string
        codecFullName:
          type: string
        codecTag:
          type: string
        format:
          type: string
        formatFullName:
          type: string
    ProjectUrls:
      type: object
      description: >-
        Presigned URLs for the project's assets. URLs expire — always use the
        most recent API response. The transcription_* subtitle/text exports are
        only present on transcription projects.
      properties:
        videoFile:
          type: string
          description: Presigned URL of the processed source video
        audioFile:
          type: string
          description: Presigned URL of the extracted audio track
        transcription:
          type: string
          description: >-
            Presigned URL of the word-level transcript JSON (the translated
            version when translation ran). Lets API consumers audit content
            without video playback.
        transcription_srt:
          type: string
          description: SRT subtitles — transcription projects only
        transcription_vtt:
          type: string
          description: WebVTT subtitles — transcription projects only
        transcription_csv:
          type: string
          description: CSV transcript — transcription projects only
        transcription_txt:
          type: string
          description: Plain-text transcript — transcription projects only
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````