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

# Get analysis status for media files

> Reports which visual, speech, face, and Summary Analysis exist in an Analysis folder
for each file, with coverage counts across all files. `cache_dir` must be an
existing folder; it doesn't have to be the active Analysis folder.

- Per-file details come only for 100 files or fewer. For more,
  `media_details_included` is false and `media` is left out. Jumper then doesn't
  hash or probe the files: files it hasn't hashed before count in
  `unresolved_media_count`, and visual and speech counts only check whether the
  file's analysis folder exists, not which model made it or whether it's complete.
- `media[].path` is the absolute path, not the string you sent. A file whose hash
  can't be resolved appears as `{path, error: "Could not resolve media hash"}`.
- Visual, face, and Summary Analysis apply to video and image files; speech to video
  and audio files. `eligible_media_count` counts the files each type applies to.




## OpenAPI

````yaml /api-reference/openapi-v1.yaml post /media/analysis-status
openapi: 3.0.3
info:
  title: Jumper Public API
  version: '1.0'
  description: >
    REST API for third-party integrations with Jumper's media analysis engine.


    Jumper analyzes video, image, and audio files — enabling semantic visual
    search,

    speech transcription, face detection with clustering, and hierarchical
    summaries.

    This API exposes those capabilities for use by MAM systems, automation
    pipelines,

    and custom tooling.


    ## Authentication


    All endpoints except `/health` require a **Jumper Pro** license key.

    The OpenAPI contract models the supported `X-License-Key` header flow.


    Jumper also accepts a `license_key` field in many JSON POST bodies as a

    convenience, but that is a Jumper-specific request-body convention rather

    than an OpenAPI security scheme. A non-empty JSON `license_key` takes

    precedence over the header.


    Send the raw license key on every authenticated request. Activating Jumper

    in the UI does not authenticate later API requests automatically. Pro uses

    the same entitlements in the UI and API; no separate API entitlement is
    needed.


    Missing keys return `401`. Supplied keys that cannot be validated or lack

    Pro entitlements return `403`. The `error` is `Jumper Pro license required`

    for both cases; inspect the response `message` for the validation reason.

    A valid non-Pro key can have `message: "OK"` and still return `403`.

    Enterprise policy denials also return `403`, with a `policy_error` field.


    Successful validation can be cached for 30 minutes. Health only checks

    connectivity and does not validate a license. The API is local to the

    machine running Jumper; use `localhost` or `127.0.0.1`.


    ## Key Concepts


    - **`cache_dir`** — The folder where Jumper stores analysis data (visual
    analysis, transcriptions, face clusters). You choose this path.

    - **`media_paths`** — Absolute filesystem paths to media files. Jumper needs
    direct access to these files.

    - **`hash_str`** — A backend-issued media identity returned by the metadata
    endpoint. Computed with xxh64 from the file size and sampled head/tail
    bytes; it is not a full-file integrity checksum.

    - **`model_key`** — Internal identifier for a visual or speech analysis
    model variant (e.g. `v2-medium-256`).
  contact:
    name: Jumper
    url: https://getjumper.io
servers:
  - url: http://localhost:6699/api/v1
    description: Local Jumper backend
security:
  - HeaderAuth: []
paths:
  /media/analysis-status:
    post:
      tags:
        - Media
      summary: Get analysis status for media files
      description: >
        Reports which visual, speech, face, and Summary Analysis exist in an
        Analysis folder

        for each file, with coverage counts across all files. `cache_dir` must
        be an

        existing folder; it doesn't have to be the active Analysis folder.


        - Per-file details come only for 100 files or fewer. For more,
          `media_details_included` is false and `media` is left out. Jumper then doesn't
          hash or probe the files: files it hasn't hashed before count in
          `unresolved_media_count`, and visual and speech counts only check whether the
          file's analysis folder exists, not which model made it or whether it's complete.
        - `media[].path` is the absolute path, not the string you sent. A file
        whose hash
          can't be resolved appears as `{path, error: "Could not resolve media hash"}`.
        - Visual, face, and Summary Analysis apply to video and image files;
        speech to video
          and audio files. `eligible_media_count` counts the files each type applies to.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - cache_dir
                - media_paths
              properties:
                cache_dir:
                  type: string
                  description: Existing Analysis folder to check
                media_paths:
                  type: array
                  items:
                    type: string
                  description: >-
                    Media files to check. Per-file details only for 100 files or
                    fewer.
      responses:
        '200':
          description: Analysis status
          content:
            application/json:
              schema:
                type: object
                required:
                  - total_media_count
                  - hashed_media_count
                  - unresolved_media_count
                  - media_details_included
                  - coverage
                  - analysis_options
                properties:
                  total_media_count:
                    type: integer
                  hashed_media_count:
                    type: integer
                  unresolved_media_count:
                    type: integer
                    description: Files whose hash couldn't be resolved
                  media_details_included:
                    type: boolean
                    description: True for 100 files or fewer
                  coverage:
                    type: object
                    description: >-
                      Counts per analysis type (visual, speech, face, summary).
                      Visual and speech also have loaded_media_count, the files
                      whose analysis is loaded in memory for searching.
                    additionalProperties:
                      type: object
                      properties:
                        eligible_media_count:
                          type: integer
                        cached_media_count:
                          type: integer
                        missing_media_count:
                          type: integer
                        loaded_media_count:
                          type: integer
                  analysis_options:
                    type: object
                    properties:
                      visual:
                        type: boolean
                      speech:
                        type: object
                        properties:
                          available:
                            type: boolean
                          languages:
                            type: array
                            items:
                              type: string
                            description: language values /analyze transcription jobs accept
                      face:
                        type: boolean
                      summary:
                        type: boolean
                  media:
                    type: array
                    description: Present only when media_details_included is true
                    items:
                      type: object
                      properties:
                        path:
                          type: string
                          description: Absolute path
                        hash_str:
                          type: string
                        error:
                          type: string
                          description: >-
                            Present instead of the analysis fields when the hash
                            couldn't be resolved
                        visual_analysis:
                          type: object
                          properties:
                            cached:
                              type: boolean
                            model_key:
                              type: string
                              nullable: true
                              description: Visual model the analysis was made with
                            search_compatible_with_current_model:
                              type: boolean
                        speech_analysis:
                          type: object
                          properties:
                            cached:
                              type: boolean
                            language:
                              type: string
                              nullable: true
                              description: ISO language code of the transcript
                        face_analysis:
                          type: object
                          properties:
                            cached:
                              type: boolean
                            collections:
                              type: array
                              items:
                                type: object
                                properties:
                                  collection_name:
                                    type: string
                                  face_appearances:
                                    type: integer
                                  named_people:
                                    type: array
                                    items:
                                      type: string
                        summary_analysis:
                          type: object
                          properties:
                            cached:
                              type: boolean
                            analysis_count:
                              type: integer
                            analyses:
                              type: array
                              description: >-
                                The file's Summary Analyses, as /summaries/list
                                lists them
                              items:
                                type: object
        '400':
          description: >-
            cache_dir doesn't exist, or media_paths is missing or has no valid
            paths
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '401':
          $ref: '#/components/responses/AuthenticationRequired'
        '403':
          $ref: '#/components/responses/Forbidden'
        '500':
          description: Failed to read analysis status
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
components:
  schemas:
    Error:
      type: object
      properties:
        error:
          type: string
          description: Error message
        message:
          type: string
          description: >-
            Additional validation detail. Authentication failures include this
            field.
      required:
        - error
    PolicyError:
      type: object
      required:
        - policy_error
      properties:
        policy_error:
          type: string
          description: Enterprise policy restriction that denied the request.
  responses:
    AuthenticationRequired:
      description: >-
        No license key was supplied in X-License-Key or the JSON license_key
        field.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: Authentication required
            message: Provide license_key in request body or X-License-Key header
    Forbidden:
      description: >-
        The supplied key could not be validated, lacks Pro entitlements, or an
        Enterprise policy denied the action. Inspect message or policy_error for
        the reason.
      content:
        application/json:
          schema:
            oneOf:
              - $ref: '#/components/schemas/Error'
              - $ref: '#/components/schemas/PolicyError'
          examples:
            invalidKey:
              summary: License key does not exist
              value:
                error: Jumper Pro license required
                message: >-
                  License invalid and activation not required: license does not
                  exist
            nonProKey:
              summary: Valid license without Pro entitlements
              value:
                error: Jumper Pro license required
                message: OK
            policyDenied:
              summary: Enterprise policy denied the action
              value:
                policy_error: >-
                  This action is not available under your organization's Jumper
                  policy
  securitySchemes:
    HeaderAuth:
      type: apiKey
      in: header
      name: X-License-Key
      description: >-
        Raw Jumper Pro license key on every authenticated request, without a
        Bearer prefix

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.