> ## 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.

# Read an XMEML or FCPXML timeline

> Reads a Premiere Pro XML (XMEML) or Final Cut Pro XML (FCPXML) timeline and returns
its clips in the shape `/export/premiere-xml` accepts, so you can read a sequence,
change it, and export it again. Send the XML as a file path or as a string.

- Clips are sorted by timeline position. `start_seconds` and `end_seconds` are the
  source in and out points, counted from the start of the media file.
  `timeline_start_seconds` counts from the start of the sequence.
- A video and an audio clip with the same source, source range, and timeline
  position become one `both` clip with `video_track_index` and `audio_track_index`;
  other clips have `track_index`. Track indices are one-based.
- Clips whose source file can't be resolved are skipped and named in `warnings`.
  XMEML transitions become cuts, also with a warning.




## OpenAPI

````yaml /api-reference/openapi-v1.yaml post /timeline/parse-xml
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:
  /timeline/parse-xml:
    post:
      tags:
        - Export
      summary: Read an XMEML or FCPXML timeline
      description: >
        Reads a Premiere Pro XML (XMEML) or Final Cut Pro XML (FCPXML) timeline
        and returns

        its clips in the shape `/export/premiere-xml` accepts, so you can read a
        sequence,

        change it, and export it again. Send the XML as a file path or as a
        string.


        - Clips are sorted by timeline position. `start_seconds` and
        `end_seconds` are the
          source in and out points, counted from the start of the media file.
          `timeline_start_seconds` counts from the start of the sequence.
        - A video and an audio clip with the same source, source range, and
        timeline
          position become one `both` clip with `video_track_index` and `audio_track_index`;
          other clips have `track_index`. Track indices are one-based.
        - Clips whose source file can't be resolved are skipped and named in
        `warnings`.
          XMEML transitions become cuts, also with a warning.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              description: Send xml_path or xml_string.
              properties:
                xml_path:
                  type: string
                  description: XMEML or FCPXML file to read
                xml_string:
                  type: string
                  description: >-
                    The XML itself. Used instead of xml_path when both are
                    given.
      responses:
        '200':
          description: Parsed timeline
          content:
            application/json:
              schema:
                type: object
                properties:
                  format:
                    type: string
                    enum:
                      - xmeml
                      - fcpxml
                  sequence_name:
                    type: string
                  timebase:
                    type: integer
                    description: Nominal sequence frame rate
                  ntsc:
                    type: boolean
                    description: Whether the timebase is reduced by 1000/1001
                  frame_rate:
                    type: number
                    description: >-
                      Resulting sequence frame rate, e.g. 29.97002997 for
                      timebase 30 with ntsc
                  clip_count:
                    type: integer
                  clips:
                    type: array
                    items:
                      type: object
                      required:
                        - source_path
                        - start_seconds
                        - end_seconds
                        - timeline_start_seconds
                        - track
                        - label
                        - fps
                      properties:
                        source_path:
                          type: string
                        start_seconds:
                          type: number
                          description: Source in point, from the start of the media file
                        end_seconds:
                          type: number
                          description: Source out point, from the start of the media file
                        timeline_start_seconds:
                          type: number
                          description: Position from the start of the sequence
                        track:
                          type: string
                          enum:
                            - video
                            - audio
                            - both
                        track_index:
                          type: integer
                          description: One-based track for video or audio clips
                        video_track_index:
                          type: integer
                          description: One-based video track for both clips
                        audio_track_index:
                          type: integer
                          description: One-based audio track for both clips
                        label:
                          type: string
                        fps:
                          type: number
                          description: Source frame rate
                        source_duration_seconds:
                          type: number
                        has_audio:
                          type: boolean
                        audio_channels:
                          type: integer
                          description: Set for Premiere stereo audio
                        audio_sample_rate:
                          type: integer
                  warnings:
                    type: array
                    items:
                      type: string
        '400':
          description: >
            Invalid request. The `error` is one of:


            - `Provide xml_path or xml_string`

            - `Invalid XML: <details>`

            - `Unsupported XML root element '<root>'. Expected xmeml or fcpxml.`

            - `No <sequence> found in XMEML document.` or `No <sequence> found
            in FCPXML document.`
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '401':
          $ref: '#/components/responses/AuthenticationRequired'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          description: 'xml_path doesn''t exist (`XML file not found: <path>`)'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '500':
          description: Failed to read the timeline
          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.