# Add Avid Media Composer media to Jumper Source: https://docs.getjumper.io/NLE/avid/avid-adding-media Load Avid clips into Jumper using the correct workflow for transcoded MXF media or linked and AMA clips, including multi-machine metadata setup. Avid media falls into two types. The workflow depends on which you have. Subclips and grouped/multicam clips are supported in Media Composer 2025.12.2 and 2026.8. Requires Jumper build 3361 (Apple silicon) / 3362 (Intel) on macOS, or build 1628 on Windows, or later. ## Transcoded MXF in Avid MediaFiles ### If the MXF has already been analyzed When Jumper has already analyzed the MXF files, MOB ID metadata is calculated during analysis. You can skip **Scan MXF Metadata** for those files and load them directly. If multiple machines work on the same footage, set a shared directory in [Settings](/interface/settings-tab#shared-mxf-metadata) under **Shared MXF Metadata**. Use the same path on every machine, including the machine that ran analysis. Select the clips you want to load. Click **Load Media** -> **All Selected Clips** (or **All Visible Clips**, **All Bins**). Load Media dropdown options When an analyzed MXF is loaded, Jumper automatically sends the MOB ID to the Avid plugin. That links the bin clip to the managed media without a separate scan step. ### If the MXF has not been analyzed You still need to scan before Jumper can link bin clips to the MXF files. To share scan results across multiple machines, set a shared directory in [Settings](/interface/settings-tab#shared-mxf-metadata) under **Shared MXF Metadata**. Use the same path on every machine. Click **Scan MXF Metadata** in the Media tab (next to the filename filter). Scan MXF Metadata button location Select the clips you want to load. Click **Load Media** -> **All Selected Clips** (or **All Visible Clips**, **All Bins**). Load Media dropdown options Without the scan, Jumper cannot link bin clips to unanalyzed MXF files. If you see "can't link to a clip" or media fails to load, run the scan first. ## Linked or AMA clips No scan needed. Select clips in a bin, then **Load Media** -> **All Selected Clips** (or **All Visible Clips**, **All Bins**). ## Can't add media? **Clips not selected** — For **All Selected Clips**, you must select clips in the bin before clicking Load Media. Click the clips you want in the open bin(s), then use the dropdown. **Scan not run** — If you have transcoded MXF that has **not** been analyzed and media fails to load, run **Scan MXF Metadata** first (see [If the MXF has not been analyzed](#if-the-mxf-has-not-been-analyzed) above). # Install Jumper for Avid Media Composer Source: https://docs.getjumper.io/NLE/avid/avid-guide Install the Jumper panel for Avid Media Composer on macOS or Windows, open it from Avid, load media, and configure required shortcuts. This guide installs the Jumper panel for Avid Media Composer and explains where to open it, how to populate the Media tab, and which Avid shortcuts Jumper uses. ## Instructions Make sure that Jumper is installed, and `JumperHelper` has **Accessibility Permission**, and `Jumper.app` has **Full Disk Access**. If you install Jumper for Final Cut Pro, it will prompt you for these. jh-accessibility-permission.png jumper-full-disk-access.png Make sure that Avid Media Composer and all it's various helper apps (such as `avid-api-gateway`) are closed in **Activity Monitor / Task Manager**. For example, quit these: avid-01.png Launch `Jumper.app` from your **Application** folder. avid-02.png Click **Enable Jumper in Avid Media Composer**. avid-03.png This will install the Avid Panel. For those that care, the Jumper Avid Panel exists in `/Library/Application Support/Avid/PanelSDKPlugins/jumper.avpi`. You can now launch **Avid Media Composer**. Create a new Avid project or open and existing Avid project. You'll find Jumper in **Tools -> Jumper**. In newer versions of Avid Media Composer (2025.12 and later), you can find it in **Extensions -> Jumper**. avid-04.png If you don't see Jumper in the **Tools** or **Extensions** list, see [Troubleshooting](/NLE/avid/avid-troubleshooting#panel-wont-open). When you click on **Jumper** it will launch the Jumper for Avid Media Composer panel. avid-05.png The only real difference between Jumper for Avid Media Composer and Jumper for DaVinci Resolve, Final Cut Pro and Adobe Premiere Pro is the **Media Panel**. In Jumper for Avid Media Composer, you populate the Media table using the **Scan MXF Metadata** button and the **Load Media** dropdown (next to the filename filter in the Media tab). If the MXF has already been analyzed, you can often skip the scan step. See [Adding media](/NLE/avid/avid-adding-media) for the full workflow. avid-06.png ## Required shortcuts Jumper relies on default Avid Media Composer shortcuts for Mark IN/OUT and playhead navigation. The Avid Panel SDK is unstable for some of these actions, so Jumper triggers keyboard shortcuts instead. | Shortcut | Avid action | | :- | :- | | **I** | Mark IN | | **O** | Mark OUT | | **Q** | Go to IN point | Custom keyboard shortcuts for **I**, **O**, or **Q** will break Mark IN/OUT, Source Viewer search, and related Jumper actions. Restore Avid's defaults for these keys, or remap them back to the standard actions. ## Match Source/Record Viewer Frame To enable this functionality you need to create a new Export Preset in Avid Media Composer called **Jumper**. In the current version of Jumper, it will automatically create this Export Preset. avid-export-preset-01.png avid-export-preset-02.png # Jumper for Avid Media Composer Source: https://docs.getjumper.io/NLE/avid/avid-index Install and use Jumper's local AI footage search in Avid Media Composer on macOS or Windows, including MXF and linked or AMA media workflows. jumper-for-avid.png Jumper adds local visual, speech, and people search to Avid Media Composer. Search analyzed footage, open matching source ranges, and add results to a sequence without uploading your media. ## What you can do in Avid Media Composer * [Search visual content, dialogue, and people](/interface/search-tab) * Search transcoded MXF media and linked or AMA clips * Open matching footage in the Source Viewer and mark the relevant range * [Search analyzed footage outside the current Avid project](/interface/search-tab#search-all-analyzed-media) * Work with subclips and grouped/multicam clips (Media Composer 2025.12.2 and 2026.8) ## Compatibility | Requirement | Details | | :- | :- | | OS | macOS Sonoma v14.0+, Windows 10+ | | Hardware | Apple Silicon Mac, Intel Mac & Windows PC | | Software | Avid Media Composer v2023.8 and later | | Additional | Rosetta required for `ffmpeg` on Apple Silicon | Jumper currently supports **Avid Media Composer v2023.8** and later, but has been optimised to work great on the latest **Avid Media Composer v2025.12**. If you don't already have `ffmpeg` installed on your system, Jumper currently also requires **Rosetta** on Apple Silicon Macs, as the version of `ffmpeg` Jumper downloads is not currently a Universal Binary. Jumper will install `ffmpeg` automatically if you don't already have it installed. Subclips and grouped/multicam clips require Media Composer 2025.12.2 or 2026.8, and Jumper build 3361 (Apple silicon) / 3362 (Intel) on macOS, or build 1628 on Windows, or later. ## Documentation ### Installation Step-by-step guide to install Jumper for Avid Media Composer ### Adding media Load transcoded MXF or linked/AMA clips into Jumper. Includes troubleshooting if media won't load. Jumper not showing in Tools or Extensions, can't add media, scan fails, installation issues. ## Demo Videos You can watch a 16min video demonstrating Jumper over at [FCP Cafe](https://fcp.cafe/news/20250610-02/). The below video was created on **8th May 2025**, using **Jumper v2025.05.07 (Build 1847)** by Chris Hocking from [LateNite](https://latenitefilms.com). This was an early beta version of Jumper for Avid Media Composer, so things may have changed and evolved since this video was posted. # Troubleshoot Jumper for Avid Media Composer Source: https://docs.getjumper.io/NLE/avid/avid-troubleshooting Fix a missing Jumper panel, media-linking failures, broken Mark IN or OUT actions, shortcut conflicts, and MXF metadata scan problems in Avid. Use this guide when the Jumper panel is missing in Avid Media Composer, media will not load, Source Viewer actions fail, or an MXF metadata scan does not complete. ## Panel won't open On newer versions of Avid Media Composer (2025.12 and later), Jumper is now available in the Extensions menu. Go to **Tools -> Console** In the Console window that opens, type in panelsdk reinit and hit Enter Avid Console showing panelsdk reinit command and Gateway service ready message If you get some error message, enter the command again until you see "PanelSDK: Gateway service is ready." If Jumper still doesn't appear, restart your computer. Several users have found this fixes it (we're not sure why, and are actively discussing with the Avid team). ## Can't add media Media won't load or you see "can't link to a clip"? See [Adding media](/NLE/avid/avid-adding-media#cant-add-media) for the full workflow and common fixes: * **Clips not selected** — For **All Selected Clips**, select clips in the bin before clicking Load Media. * **Scan not run** — For unanalyzed transcoded MXF, run **Scan MXF Metadata** first. Analyzed MXF can skip the scan step. ## Mark IN/OUT or Source Viewer search fails Jumper uses Avid's default **I** (Mark IN), **O** (Mark OUT), and **Q** (Go to IN point) shortcuts. Custom shortcuts for these keys will break navigation and Source Viewer search. See [Required shortcuts](/NLE/avid/avid-guide#required-shortcuts) in the installation guide. ## Scan MXF Metadata / Scan Avid MediaFiles fails If **Scan MXF Metadata** or **Scan Avid MediaFiles** still doesn't successfully scan the drive that contains your Avid media, contact us on the [Discord](https://discord.getjumper.io). ## Installation issues If the Jumper panel fails to install or enable: 1. **Close Avid and helper apps** — Quit Avid Media Composer and `avid-api-gateway` (and any other Avid helper processes) in **Activity Monitor** (macOS) or **Task Manager** (Windows) before enabling Jumper. 2. **Re-run the enable step** — In Jumper.app, click **Enable Jumper in Avid Media Composer** again. # Jumper for Final Cut Pro Source: https://docs.getjumper.io/NLE/fcp/fcp-index Install and use Jumper's local AI footage search as a Final Cut Pro workflow extension on macOS, with visual, speech, and people search. jumper-for-fcp-banner.avif Jumper adds local visual, speech, and people search to Final Cut Pro. Search analyzed footage, open matching source ranges, and add results to a timeline without uploading your media. ## What you can do in Final Cut Pro * [Search visual content, dialogue, and people](/interface/search-tab) * Open matching footage in the Event Viewer and mark the relevant range * Add search results to a Final Cut Pro timeline * [Search analyzed footage outside the current Final Cut Pro library](/interface/search-tab#search-all-analyzed-media) ## Compatibility | Requirement | Details | | :- | :- | | OS | macOS Sonoma 14.0+ (Metal 3.1 required). Recommended: macOS 26 | | Hardware | Apple Silicon Mac, Intel Mac | | Software | Final Cut Pro 10.6.5 or later | Detailed installation guide on how to install Jumper for Final Cut Pro # Jumper integrations for video editing software Source: https://docs.getjumper.io/NLE/nle_integrations Use Jumper's local AI footage search directly inside Adobe Premiere Pro, Final Cut Pro, DaVinci Resolve Studio, and Avid Media Composer. Jumper integrates directly with **Adobe Premiere Pro, Final Cut Pro, DaVinci Resolve Studio, and Avid Media Composer**. It runs locally on macOS or Windows and adds visual, speech, and people search to your editing workflow. ## Supported editing software | Editing software | Operating systems | Setup guide | | - | - | - | | Adobe Premiere Pro | macOS and Windows | [Jumper for Adobe Premiere Pro](/NLE/premiere/premiere-index) | | Final Cut Pro | macOS | [Jumper for Final Cut Pro](/NLE/fcp/fcp-index) | | DaVinci Resolve Studio | macOS and Windows | [Jumper for DaVinci Resolve Studio](/NLE/resolve/resolve-index) | | Avid Media Composer | macOS and Windows | [Jumper for Avid Media Composer](/NLE/avid/avid-index) | See [Jumper compatibility and system requirements](/compatibility) for minimum application and operating-system versions. ## What the integrations do Inside your editing software, Jumper can: * Analyze media for [visual search](/core-concepts/visual-search), [speech search](/core-concepts/speech-search), and [people search](/core-concepts/face-detection) * Open matching footage and mark the relevant range * Add search results to a timeline or sequence * [Search all analyzed media](/interface/search-tab#search-all-analyzed-media), including footage outside the current project and on disconnected storage drives The search and analysis workflow is consistent across integrations. Installation, media linking, keyboard shortcuts, and timeline actions vary by editing software. Compatibility, setup, and troubleshooting for the Jumper panel in Premiere Pro. Compatibility, permissions, and installation for the Jumper workflow extension in Final Cut Pro. Requirements and installation for Jumper in DaVinci Resolve Studio. Installation, media linking, and troubleshooting for Jumper in Avid Media Composer. # Jumper for Adobe Premiere Pro Source: https://docs.getjumper.io/NLE/premiere/premiere-index Use Jumper's local AI footage search inside Adobe Premiere Pro on macOS or Windows, then open results, mark ranges, and add clips to a sequence. jumper-for-premiere.png Jumper adds local visual, speech, and people search to Adobe Premiere Pro. Analyze footage once, find relevant moments with natural-language queries, and use the results without uploading source media. ## What you can do in Premiere Pro * [Search visual content, dialogue, and people](/interface/search-tab) * Open a matching clip in the Source Monitor and mark the relevant range * Insert or overwrite a result in the active sequence * [Search analyzed footage outside the current Premiere Pro project](/interface/search-tab#search-all-analyzed-media) ## Compatibility | Requirement | Details | | :- | :- | | OS | macOS Sonoma 14.0+ (macOS 26 recommended), Windows | | Hardware | Apple Silicon Mac, Intel Mac, PC | | Software | Adobe Premiere Pro v24.0.0 | | Additional | Rosetta required for `ffmpeg` on Apple Silicon | ## Notable differences * Add to timeline behaviors: Insert, Overwrite ## Open Jumper in Premiere Pro After installing and launching Jumper, open **Window -> Extensions -> Jumper** in Premiere Pro. Follow the [Jumper quickstart](/quickstart) to analyze media and run your first search. Reinstall the extension when Jumper does not appear in Premiere Pro's Extensions menu. # Fix the Jumper panel not opening in Premiere Pro Source: https://docs.getjumper.io/NLE/premiere/premiere-panel-not-opening Reinstall the Jumper extension when its panel does not appear under Window > Extensions in Adobe Premiere Pro on macOS or Windows. If Jumper does not appear under **Window -> Extensions** in Adobe Premiere Pro, first launch the Jumper app. If the panel is still missing, reinstall its ZXP extension. ## Reinstall the Jumper Premiere Pro extension On macOS make sure you start the Jumper launcher app via Spotlight after installing the .DMG file you downloaded. If it's still not showing up, you can download a third-party installation tool called [ZXPInstaller](https://zxpinstaller.com/). Open the program after downloading and installing it, then drag-and-drop the zxp-file into the program. ### Location of the zxp-file ```javascript macOS theme={null} ~/Applications/Jumper.app/Contents/Resources/Jumper.zxp ``` ```python Windows theme={null} C:\Program Files (x86)\Jumper\_internal\Jumper.zxp ``` # Install Jumper for DaVinci Resolve Studio Source: https://docs.getjumper.io/NLE/resolve/resolve-guide Install Jumper for DaVinci Resolve Studio on macOS or Windows, enable external scripting, open the integration, and verify required shortcuts. This guide connects Jumper to the paid **DaVinci Resolve Studio** edition. It covers macOS and Windows setup, Resolve external-scripting settings, required shortcuts, and common playhead problems. ## Instructions Make sure that Jumper is installed, and `JumperHelper` has **Accessibility Permission**, and `Jumper.app` has **Full Disk Access**. If you install Jumper for DaVinci Resolve, it will prompt you for these. jh-accessibility-permission.png jumper-full-disk-access.png Launch `Jumper.app` from your **Application** folder. avid-02.png Click the **Enable Jumper in DaVinci Resolve** toggle: jumper-resolve-01.png Launch DaVinci Resolve. Create a new Project or open an existing Project. Go to **DaVinci Resolve -> Preferences** from the menubar. jumper-resolve-02.png In the **General** tab, make sure that **External scripting using** is set to **Local** or **Network**. jumper-resolve-03.png You can now launch Jumper from the **Workspace -> Workflow Integrations -> Jumper** menubar. jumper-resolve-04.png You're now good to use Jumper, the same as in other editing software. 🥳 jumper-resolve-05.png Install Jumper. Jumper will run in the background in the taskbar / system tray. Start DaVinci Resolve. Open Jumper from the Resolve menu. Follow the onboarding process. ## Required shortcuts Jumper relies on default DaVinci Resolve shortcuts and menu paths to work around gaps in the Resolve API. If you use custom keyboard shortcuts, these features may not work correctly. | Shortcut / Action | Purpose | | :- | :- | | **Shift + I** | "Go to in point" — moves the playhead in the Source Monitor when Jumper marks in/out | | **Ctrl + 3** (Windows) / **Cmd + 3** (macOS) | Export current frame from Source Viewer — used for the Match Source button | | **Workspace -> Active Panel Selection -> Source Viewer** | Focus the Source Viewer — used when exporting a frame for Match Source | Custom keyboard shortcuts will break playhead movement, Match Source, and related features. Use DaVinci Resolve's default shortcuts, or restore them for these actions. DaVinci Resolve must be set to **English** for the menu automation (Workspace -> Active Panel Selection -> Source Viewer) to work. ## Troubleshooting ### Playhead doesn't move when marking in/out Jumper uses **Shift + I** ("Go to in point") to move the playhead after marking in/out. If the playhead doesn't move, or the search term appears before the in point, you likely have a custom keyboard shortcut that overrides the default. See [Required shortcuts](#required-shortcuts) above. # Jumper for DaVinci Resolve Studio Source: https://docs.getjumper.io/NLE/resolve/resolve-index Install and use Jumper's local AI footage search in DaVinci Resolve Studio on macOS or Windows. The paid Studio edition is required. jumper-for-resolve.png Jumper adds local visual, speech, and people search to DaVinci Resolve Studio. Search analyzed footage, open matching source ranges, and add results to a timeline without uploading your media. ## What you can do in DaVinci Resolve * [Search visual content, dialogue, and people](/interface/search-tab) * Open matching footage in the Source Viewer and mark the relevant range * Add search results to a Resolve timeline * [Search analyzed footage outside the current Resolve project](/interface/search-tab#search-all-analyzed-media) ## Compatibility Jumper requires the paid **Blackmagic DaVinci Resolve Studio** version - NOT the free version. | Requirement | Details | | :- | :- | | OS | macOS Sonoma 14.0+ (Metal 3.1 required). Recommended: macOS 26. Windows 10 or later | | Hardware | Apple Silicon Mac (Intel support coming soon), Windows PC | | Software | Blackmagic DaVinci Resolve Studio 19.0.3 or later (latest tested: 20) Paid version only | | Additional | Rosetta required for `ffmpeg` on Apple Silicon | Jumper relies on default DaVinci Resolve shortcuts. If you use custom keyboard shortcuts, see the [installation guide](/NLE/resolve/resolve-guide#required-shortcuts) for details. Detailed installation guide on how to install Jumper for DaVinci Resolve # Load all analysis data into memory Source: https://docs.getjumper.io/api-reference/analysis-data/load-all-analysis-data-into-memory /api-reference/openapi-v1.yaml post /analysis-data/load Loads all visual analysis data, people metadata, and transcriptions from the analysis folder into memory. Must be called before searching, unless you use `/analysis-data/load-for-media` instead. # Load analysis data for specific media files Source: https://docs.getjumper.io/api-reference/analysis-data/load-analysis-data-for-specific-media-files /api-reference/openapi-v1.yaml post /analysis-data/load-for-media Selectively loads visual analysis data for the given video or image files only. More efficient than loading everything when you only need to search across a subset of media. Skips files whose visual data is already in memory. This endpoint does not load transcription data. Use `/analysis-data/load` to load everything, or `/analysis-data/load-transcriptions` for transcript-only workflows. # Load transcription data into memory Source: https://docs.getjumper.io/api-reference/analysis-data/load-transcription-data-into-memory /api-reference/openapi-v1.yaml post /analysis-data/load-transcriptions Loads all transcription data from the analysis folder into memory. This enables the `/search/transcript` endpoint. Transcription data is also loaded automatically when using `/analysis-data/load`. Does not require a specific whisper model to be loaded — transcriptions from any supported model are loaded. # Cancel running analysis Source: https://docs.getjumper.io/api-reference/analysis/cancel-running-analysis /api-reference/openapi-v1.yaml post /analyze/cancel Requests cancellation of any currently running analysis task. # Start media analysis Source: https://docs.getjumper.io/api-reference/analysis/start-media-analysis /api-reference/openapi-v1.yaml post /analyze Starts an asynchronous analysis pipeline. Returns immediately with a `task_id` that can be used to track progress via SocketIO. You can run visual analysis, speech transcription, face clustering, and hierarchical Summary Analysis in a single call. The REST endpoint runs directly and does not require an MCP client, agent, or approval step. Summary Analysis requires a supported Apple silicon or Windows device and a locally downloaded Summary model. Each summary path must already have complete visual analysis or be included in `visual_media_paths` in the same request. For throughput, batch many files into one request instead of sending many single-file requests. Jumper loads ML models per analysis request, so one 50-file request is much faster than 50 one-file requests on the same node. Only one analysis task can run at a time per backend instance. A new analyze request first asks the current task to stop. If the previous task is still unwinding, Jumper returns `409`. # Export transcript to file Source: https://docs.getjumper.io/api-reference/export/export-transcript-to-file /api-reference/openapi-v1.yaml post /export/transcript Export transcript segments to a file in TXT, CSV, DOCX, or PDF format. If output_path is omitted, saves to ~/Desktop/{display_name}.{format}. # Export trimmed video clips Source: https://docs.getjumper.io/api-reference/export/export-trimmed-video-clips /api-reference/openapi-v1.yaml post /export/clips Exports trimmed video clips to a folder using ffmpeg. Each clip specifies a source file and in/out points. Supports subfolder organization. # Generate Premiere Pro XML sequence Source: https://docs.getjumper.io/api-reference/export/generate-premiere-pro-xml-sequence /api-reference/openapi-v1.yaml post /export/premiere-xml Generates a Premiere Pro compatible XML sequence file (XMEML v4) from a list of clips. The XML can be imported into Premiere Pro, DaVinci Resolve, Avid, or other NLEs. # Get paginated cluster faces Source: https://docs.getjumper.io/api-reference/face-clustering/get-paginated-cluster-faces /api-reference/openapi-v1.yaml post /faces/clusters/faces Returns face images for specific cluster(s) with pagination support. # Get sample face images per cluster Source: https://docs.getjumper.io/api-reference/face-clustering/get-sample-face-images-per-cluster /api-reference/openapi-v1.yaml post /faces/clusters/samples Returns a few sample face thumbnail images for each cluster in a job. Useful for building a "who is this person?" UI. # List face clustering jobs Source: https://docs.getjumper.io/api-reference/face-clustering/list-face-clustering-jobs /api-reference/openapi-v1.yaml get /faces/clusters Returns all clustering jobs and summary statistics for each. # Merge or move faces between clusters Source: https://docs.getjumper.io/api-reference/face-clustering/merge-or-move-faces-between-clusters /api-reference/openapi-v1.yaml post /faces/clusters/modify Merge entire clusters together, or move individual faces between clusters. Useful for correcting clustering mistakes. # Re-run face clustering Source: https://docs.getjumper.io/api-reference/face-clustering/re-run-face-clustering /api-reference/openapi-v1.yaml post /faces/recluster Re-runs clustering on existing face detections with new parameters. Runs asynchronously — returns a task_id for progress tracking. # Rename clusters Source: https://docs.getjumper.io/api-reference/face-clustering/rename-clusters /api-reference/openapi-v1.yaml put /faces/clusters/names Assign human-readable names to clusters (e.g. "John", "Sarah"). # Health check Source: https://docs.getjumper.io/api-reference/health/health-check /api-reference/openapi-v1.yaml get /health Returns server status. No authentication required. # Jumper Public API Source: https://docs.getjumper.io/api-reference/introduction Overview of the Jumper Public API v1, with direct links to the canonical OpenAPI YAML and full Markdown reference for agents and integration tooling. Jumper analyzes video, image, and audio files locally on the machine running the backend. The public API lets MAM systems, automation scripts, AI agents, and custom integrations use Jumper's media analysis engine for semantic visual search, speech transcription, hierarchical summaries, thumbnails, face clustering, watch folders, and exports. **Base URL:** `http://localhost:6699/api/v1` Canonical Jumper Public API v1 resources for scraping or inspection: * Raw OpenAPI YAML: `/api-reference/openapi-v1.yaml` * Raw OpenAPI JSON: `/api-reference/openapi.json` * Markdown endpoint guide: `/api-reference/public-api-v1.md` * Site-wide discovery files: `/llms.txt` and `/llms-full.txt` Prefer the raw OpenAPI YAML or JSON for endpoint paths, request schemas, response schemas, and auth. Use the Markdown endpoint guide for workflow notes, examples, and behavior details that are easier to read as prose. ## Canonical files These files are served directly from the docs site and are the best entry points for tools that need to inspect the API. Raw OpenAPI 3.0 contract for endpoint discovery, schemas, and generated clients. Raw JSON mirror of the OpenAPI contract. Markdown export with examples, workflow notes, and endpoint behavior. ## Authentication Every endpoint except `GET /health` requires a **Jumper Pro** license key. Use the `X-License-Key` header when possible. ```bash Header theme={null} curl -H "X-License-Key: YOUR_KEY" http://localhost:6699/api/v1/models/loaded ``` ```json Body theme={null} { "license_key": "YOUR_KEY", "cache_dir": "/Users/me/JumperAnalysis", "media_paths": [] } ``` ## Typical workflow Verify the backend is running with `GET /health`. Run visual analysis, transcription, optional face clustering, and optional Summary Analysis with `POST /analyze`. REST analysis runs directly and does not require MCP, an agent, or approval prompts. Use the returned `task_id` with Socket.IO progress events. In Socket.IO terms, emit `join` with the `task_id`, then listen for `progress`. Discover completed analyses with `POST /summaries/list` or `POST /summaries/collections`, then read an overview and drill into selected nodes. This step is optional when Summary Analysis was not requested. Load all analysis data with `POST /analysis-data/load`, visual data for selected media with `POST /analysis-data/load-for-media`, or transcript-only data with `POST /analysis-data/load-transcriptions`. Search visually, search transcripts, fetch transcriptions, get thumbnails, inspect face clusters, or export clips and transcripts. Batch many files into one `POST /analyze` request when possible. Jumper loads ML models per analysis request, so one larger request is much faster than many one-file requests on the same backend. ## Endpoint groups | Area | Endpoints | | - | - | | Health | `GET /health` | | Models | `GET /models/loaded`, `GET /models/available`, `POST /models/load` | | Media | `POST /media/metadata` | | Analysis | `POST /analyze`, `POST /analyze/cancel` | | Summaries | `POST /summaries/collections`, `POST /summaries/list`, `POST /summaries/overview`, `POST /summaries/node` | | Analysis data | `POST /analysis-data/load`, `POST /analysis-data/load-for-media`, `POST /analysis-data/load-transcriptions` | | Search | `POST /search/text`, `POST /search/image`, `POST /search/frame`, `POST /search/transcript` | | Transcriptions | `POST /transcriptions`, `POST /transcriptions/range` | | Thumbnails | `POST /thumbnails`, `POST /thumbnails/scene` | | Face clustering | `GET /faces/clusters`, `POST /faces/clusters/samples`, `POST /faces/clusters/faces`, `PUT /faces/clusters/names`, `POST /faces/recluster`, `POST /faces/clusters/modify` | | Watch folders | `GET /watch-folders`, `POST /watch-folders`, `PUT /watch-folders/{watch_folder_id}`, `DELETE /watch-folders/{watch_folder_id}`, `POST /watch-folders/service/start`, `POST /watch-folders/service/stop`, `GET /watch-folders/service/status` | | Cache paths | `POST /cache-paths` | | Export | `POST /export/clips`, `POST /export/premiere-xml`, `POST /export/transcript` | ## Important behavior notes Only one analysis task can run at a time per backend instance. A new `POST /analyze` request first asks the current task to stop. If the previous task is still unwinding, Jumper returns `409`. The returned REST `task_id` identifies a Socket.IO room; there is currently no durable REST status or resume endpoint. Summary Analysis requires a supported Apple silicon or Windows device, a downloaded Summary model, and complete visual analysis for each file. Include the same path in `visual_media_paths` to generate the visual dependency in one request. Use the `/summaries/*` read endpoints instead of depending on private cache files. `POST /search/text`, `POST /search/image`, and `POST /search/frame` return matches ordered best-first, but they do not return similarity scores. The optional `exclude` field is a soft ranking signal, not a hard filter. Use `people_filter` on `POST /search/text` to restrict visual search results to named people or cluster IDs. When multiple people are supplied, `people_filter_mode` defaults to `"and"`, which requires every selected person in the same frame; set it to `"or"` to match frames containing any selected person. Visual search matches use `frame_idx` as a string on the 1-FPS embedding grid, include a base64 JPEG `image`, and provide `scene_start_timestamp`, `scene_end_timestamp`, `original_index`, `hash_str`, and `video_path`. Watch folders support `excluded_extensions` and `excluded_filename_globs`. Glob patterns match the filename only, not the full path. Use `POST /export/transcript` to export transcript segments to `txt`, `csv`, `docx`, or `pdf`. ## Example requests ```bash Health theme={null} curl http://localhost:6699/api/v1/health ``` ```bash Analyze theme={null} curl -X POST http://localhost:6699/api/v1/analyze \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "visual_media_paths": ["/Videos/interview.mp4"], "transcription_jobs": [{"path": "/Videos/interview.mp4", "language": "english"}] }' ``` ```bash Summary analysis theme={null} curl -X POST http://localhost:6699/api/v1/analyze \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "visual_media_paths": ["/Videos/episode-03.mov"], "summary_requests": [{ "path": "/Videos/episode-03.mov", "analysis_id": "story-pass", "analysis_name": "Episode 3 story pass", "collection": {"name": "Season 2"}, "footage_context": "An unscripted television episode about commercial fishing", "summary_objective": { "preset": "unscripted_story", "priority_hints": ["reveals_reversals", "conflict"] } }] }' ``` ```bash Text search theme={null} curl -X POST http://localhost:6699/api/v1/search/text \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "query": "dog on a beach", "exclude": ["water", "swimming pool"], "cache_dir": "/Users/me/JumperAnalysis", "media_paths": ["/Videos/interview.mp4"], "max_results": 10 }' ``` ```bash Export transcript theme={null} curl -X POST http://localhost:6699/api/v1/export/transcript \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "segments": [[0.32, "Hello world.", 5.84]], "format": "txt", "display_name": "My Transcript" }' ``` Use the generated endpoint reference in the sidebar for request and response schemas. # Get metadata for media files Source: https://docs.getjumper.io/api-reference/media/get-metadata-for-media-files /api-reference/openapi-v1.yaml post /media/metadata Returns properties (duration, FPS, timecode) and analysis status for each media file. Use this to check which files have been analyzed and to get their `hash_str` identifiers. # Get metadata filter facets Source: https://docs.getjumper.io/api-reference/metadata-filters/get-metadata-filter-facets /api-reference/openapi-v1.yaml post /metadata/facets Returns curated metadata filter facets and coverage for a searchable scope. Call this before search to render available filter options, then pass selected filters to visual or transcript search using `metadata_filter_request`. For `mode: global`, facets are scoped to loaded searchable media for the requested `media_type`, not every row in the local metadata database. # Get currently loaded models Source: https://docs.getjumper.io/api-reference/models/get-currently-loaded-models /api-reference/openapi-v1.yaml get /models/loaded Returns the visual and speech analysis models that are currently loaded in memory. # List available models Source: https://docs.getjumper.io/api-reference/models/list-available-models /api-reference/openapi-v1.yaml get /models/available Returns all supported models for this platform, which ones are downloaded, and which is currently loaded. # Switch the active visual model Source: https://docs.getjumper.io/api-reference/models/switch-the-active-visual-model /api-reference/openapi-v1.yaml post /models/load Loads a different visual analysis model. The model must already be downloaded. This clears loaded analysis data from memory — you will need to reload it afterwards. # Public api v1 Source: https://docs.getjumper.io/api-reference/public-api-v1 # Jumper Public API v1 Base URL: `http://localhost:6699/api/v1` Jumper analyzes your media files locally on your machine. This API lets external tools (MAM systems, automation scripts, custom integrations) tap into those capabilities: semantic search across video, speech transcription, face detection and clustering, and more. *** ## Authentication Every endpoint except `/health` requires a **Jumper Pro** license key. Pass it one of two ways: | Method | Example | | - | - | | **Header** (recommended) | `X-License-Key: your-key-here` | | **JSON body** | `{"license_key": "your-key-here", ...}` | The key is validated on the first request and cached for the session — subsequent requests with the same key skip the network check. `/auth_by_settings` is an internal bootstrap endpoint and does **not** authenticate later `/api/v1` calls by itself. Public API clients should still send `X-License-Key` or `license_key` on each `/api/v1` request. **Error responses:** | Status | Meaning | | - | - | | `401` | No license key provided | | `403` | Key is valid but not a Pro license | ```json theme={null} // 401 {"error": "Authentication required", "message": "Provide license_key in request body or X-License-Key header"} // 403 {"error": "Jumper Pro license required", "message": "The public API requires a Jumper Pro license"} ``` *** ## Typical Workflow Most integrations follow this pattern: 1. **Check health** — verify the backend is running 2. **Analyze media** — run visual and/or speech analysis on your files 3. **Load analysis data** — load analysis results into memory for searching 4. **Search** — find matching moments by text, image, or frame similarity 5. **Get transcriptions** — retrieve speech-to-text results 6. **Get thumbnails** — fetch preview images for specific timestamps *** ## Endpoints ### Health #### `GET /health` No authentication required. Use this to check if the backend is running. **Response:** ```json theme={null} {"status": "ok"} ``` *** ### Models #### `GET /models/loaded` Returns which visual and speech analysis models are currently loaded in memory. **Example request:** ```bash theme={null} curl -H "X-License-Key: YOUR_KEY" http://localhost:6699/api/v1/models/loaded ``` **Response:** ```json theme={null} { "visual": { "model_key": "v2-medium-256", "is_loading": false }, "speech": { "model_key": "mlx-large-v3-turbo", "is_loading": false } } ``` #### `GET /models/available` Lists all models supported on this hardware, which are downloaded, and which is active. **Example request:** ```bash theme={null} curl -H "X-License-Key: YOUR_KEY" http://localhost:6699/api/v1/models/available ``` **Response:** ```json theme={null} { "supported_models": ["v2-medium-256", "v2-large-384", "v1-multilingual-384"], "downloaded_models": ["v2-medium-256", "v2-large-384"], "loaded_model": "v2-medium-256", "model_info": [ {"v2-medium-256": {"speed": 5, "accuracy": 3, "frame_resolution": 256, "size_gb": 0.6, "compatible_os": ["mac-arm", "mac-x86", "windows"], "is_multilingual": false}} ], "current_system": "mac-arm" } ``` `model_info` is an array of single-key objects, where each key is a `model_key` from `supported_models`. `current_system` is one of `mac-arm`, `mac-x86`, `windows`, or `linux`. #### `POST /models/load` Switches to a different visual model. The model must already be downloaded. This clears loaded analysis data from memory — you'll need to reload it afterwards. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/models/load \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{"model_key": "v2-large-384"}' ``` **Response:** ```json theme={null} { "message": "Model changed from V2 Medium to V2 Large high-res in 3.24s", "loaded_model": "v2-large-384" } ``` | Status | Meaning | | - | - | | `200` | Model switched, already active, or still loading from a previous switch | | `400` | Model key invalid or not downloaded | | `500` | Loading failed | *** ### Media Metadata #### `POST /media/metadata` Returns file properties (duration, FPS, timecode) and analysis status for each file. This is the way to check which files have been analyzed and to get their `hash_str` identifiers. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/media/metadata \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "media_paths": [ "/Videos/interview.mp4", "/Videos/photo.jpg", "/Audio/voiceover.mp3" ] }' ``` **Response:** ```json theme={null} { "media_properties": { "/Videos/interview.mp4": { "video_cached": true, "audio_cached": true, "runtime": "00:02:30", "fps": 30, "media_path": "/Videos/interview.mp4", "timecode": "00:00:00:00", "hash_str": "1e09e4953de0471b" }, "/Videos/photo.jpg": { "video_cached": true, "audio_cached": false, "runtime": "00:00:01", "fps": 0, "media_path": "/Videos/photo.jpg", "timecode": "00:00:00:00", "hash_str": "fba6b4a2d2cf672c" }, "/Audio/voiceover.mp3": { "video_cached": false, "audio_cached": true, "runtime": "00:00:03", "fps": 0, "media_path": "/Audio/voiceover.mp3", "timecode": "00:00:00:00", "hash_str": "485535a3914b2d02" } } } ``` **Fields explained:** * `video_cached` — `true` if visual analysis data exists (for videos/images) * `audio_cached` — `true` if a transcription exists (for videos/audio) * `hash_str` — unique identifier for this file, used internally and in other endpoints *** ### Analysis #### `POST /analyze` Starts analyzing media files. This is asynchronous — it returns immediately with a `task_id`, and the actual work runs in the background. You can combine visual analysis, transcription, face clustering, and named hierarchical summaries in one call. Summary generation requires a supported Apple silicon or Windows device and a locally downloaded Summary model. The REST endpoint is headless: it does not require MCP, an agent, or an approval step. Batching matters: one request with 50 files is much faster than 50 one-file requests on the same backend, because Jumper loads the ML models per analysis request. Only one analysis task can run at a time per backend instance. A new `/analyze` request first tries to stop any current task. If the previous task is still unwinding, the new request returns `409`. **Example request — visual + transcription + face clustering:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/analyze \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "detect_speakers": true, "speaker_count": "auto", "preferred_qwen_model_key": "more accurate", "visual_media_paths": [ "/Videos/interview.mp4", "/Videos/photo.jpg" ], "transcription_jobs": [ {"path": "/Videos/interview.mp4", "language": "english", "channels": [1, 3]}, {"path": "/Audio/voiceover.mp3", "language": "english"} ], "face_clustering_jobs": [ { "cluster_job_name": "Interview Faces", "face_media_paths": [ "/Videos/interview.mp4" ], "face_eps": 0.48, "face_min_samples": 5 } ] }' ``` `detect_speakers` is optional and defaults to `true`. Set it to `false` to skip final speaker diarization for the speech batch. `speaker_count` is optional and defaults to `"auto"`; accepted values are `"auto"`, `1`, `2`, `3`, `4`, and `"5+"`. For pyannote, `1`-`4` becomes `num_speakers`, while `"5+"` becomes `min_speakers=5, max_speakers=12`. `preferred_qwen_model_key` is optional and applies to Qwen-supported languages; use `"faster"` for the 0.6B model, `"more accurate"` for the 1.7B model, or `"auto"`/omit it for Jumper's default. `detect_speakers`, `speaker_count`, and `preferred_qwen_model_key` can also be supplied on individual `transcription_jobs` to override the batch setting. **Example request — with face clustering:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/analyze \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "visual_media_paths": ["/Videos/interview.mp4"], "transcription_jobs": [], "face_clustering_jobs": [ { "cluster_job_name": "Interview Faces", "face_media_paths": ["/Videos/interview.mp4"], "face_eps": 0.48, "face_min_samples": 5 } ] }' ``` **Response (202):** ```json theme={null} { "message": "Analysis started", "task_id": "550e8400-e29b-41d4-a716-446655440000" } ``` **Tracking progress:** Connect to the SocketIO server at `http://localhost:6699`, emit `join` with the returned `task_id`, then listen for `progress` events: ```json theme={null} { "progress": 45.5, "video_path": "/Videos/interview.mp4", "done": false, "type": "video" } ``` The REST `task_id` identifies the Socket.IO room. There is currently no durable REST job-status or resume endpoint, so unattended clients should retain the socket events and confirm generated summaries with the read endpoints below. Analysis endpoints accept explicit file paths; enumerate folders in the client before submitting a batch. Summary events use `type: "summary"`. During processing they may include `summary_stage` (`loading_model`, `preparing_evidence`, `generating_observations`, `generating_summary`, or `generating_short_summary`) and `summary_node_id`. Asynchronous failures include `summary_error`. Clients should accept `progress` as either a JSON number or a decimal string because Summary events currently format it as a string. | Status | Meaning | | - | - | | `202` | Analysis started | | `400` | Invalid input, no valid media files supplied, or Summary Analysis is unsupported on this platform | | `409` | Another analysis task is still stopping, or the selected Summary model is not downloaded | | `503` | Models still loading, try again shortly | **Transcription job fields:** | Field | Type | Default | Description | | - | - | - | - | | `path` | string | required | Video or audio file to transcribe | | `language` | string | `english` | Spoken language hint | | `channels` | integer array, `null`, or empty array | legacy downmix | Omit, set to `null`, or pass `[]` to use Jumper's legacy downmix-to-mono extraction. Pass a non-empty array to explicitly transcribe 1-based audio channel/track numbers; `[1]` means only channel 1. Multiple selected channels are analyzed separately, then merged with conservative near-duplicate removal. | | `preferred_qwen_model_key` | string | batch setting | Qwen model preference for Qwen-supported languages. Use `"faster"`, `"more accurate"`, or `"auto"`. | `summary_requests` is an optional array of per-file configurations. Visual analysis is the only required dependency: each `path` must already have complete visual analysis or also appear in `visual_media_paths` in the same request. Missing or disabled transcript and face evidence is non-fatal. Omitting `collection` creates a standalone analysis and is the default. Collections only organize independent per-file analyses; they do not combine clips or produce collection-level summaries. Collection names reuse existing records case-insensitively while preserving their canonical stored name and description. **Summary request fields:** | Field | Type | Default | Description | | - | - | - | - | | `path` | string | required | Visual media file to summarize. | | `analysis_id` | string | generated | Stable ID to use when replacing or addressing a named analysis. | | `analysis_name` | string | generated | Human-readable name for this analysis. | | `collection` | object or `null` | `null` | Optional grouping with required `name` and optional `id` and `description`. Omit or use `null` for a standalone analysis. | | `footage_context` | string or `null` | `null` | Factual operator context about the footage. It guides the prompt but is not source evidence. | | `summary_objective` | object | general understanding | Editorial objective with `preset`, optional `description`, and optional `priority_hints`. | | `use_transcript` | boolean | `true` | Use an existing transcript when available. Missing transcript evidence is non-fatal. | | `output_language` | string | `auto` | `auto` or a lowercase ISO language code such as `en` or `sv`. | | `face_collection` | string or `null` | `null` | Existing face-clustering job name used to resolve named people. Missing face evidence is non-fatal. | | `summary_model_key` | string | recommended model | Optional platform-compatible Summary model key. The selected model must already be downloaded. | Supported `summary_objective.preset` values are `general_understanding`, `trailer_teaser`, `action_trailer`, `visual_showcase`, `highlight_reel`, `event_recap`, `documentary_research`, `unscripted_story`, `interview_selects`, `archive_discovery`, `season_theme_analysis`, `b_roll_selects`, `social_cutdown`, `character_storyline_tracking`, `continuity_review`, and `custom`. Supported `priority_hints` are `beauty_scale`, `action_danger_violence`, `conflict`, `reactions`, `humor`, `reveals_reversals`, `strong_dialogue`, `people_relationships`, `claims_evidence`, `themes_contradictions`, `rare_material`, `clean_coverage`, `processes_demos`, `crowd_energy`, `locations_atmosphere`, and `resolutions_open_questions`. Windows Summary model keys are `qwen3-vl-2b-instruct`, `qwen3-vl-4b-instruct`, and `qwen3-vl-8b-instruct`. Apple silicon keys are `qwen3-vl-4b-instruct-8bit`, `qwen3-vl-8b-instruct-8bit`, and `qwen3-vl-32b-instruct-8bit`. Omit `summary_model_key` to use Jumper's recommended model for the machine. Download the model in the Jumper UI before starting the REST job. **Example request — visual + Summary Analysis:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/analyze \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "visual_media_paths": ["/Videos/episode-03.mov"], "summary_requests": [ { "path": "/Videos/episode-03.mov", "analysis_id": "story-pass", "analysis_name": "Episode 3 story pass", "collection": { "name": "Season 2", "description": "Broadcast episodes and selected archive material" }, "footage_context": "An unscripted television episode about commercial fishing", "summary_objective": { "preset": "unscripted_story", "description": "Preserve decisions, reversals, disagreements, and supported reactions", "priority_hints": ["reveals_reversals", "conflict"] }, "use_transcript": true, "output_language": "auto", "face_collection": "Season 2 Cast" } ] }' ``` #### `POST /analyze/cancel` Cancels any running analysis task. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/analyze/cancel \ -H "X-License-Key: YOUR_KEY" ``` **Response:** ```json theme={null} {"message": "Cancellation requested"} ``` *** ### Hierarchical Summaries Use these REST endpoints to discover and read completed Summary Analysis results. Start with a one-line overview, drill only promising branches, and use each node's `search_scope` to constrain later searches. Summary prose is navigation context rather than source proof; verify exact facts, identities, quotations, and edit points with frame, transcript, or people evidence. Use these endpoints instead of reading `summaries//summary_v3.json` directly. Cache artifacts and their directory layout are private implementation details and may change between Jumper releases. Summary reads access persisted artifacts directly and do not require `/analysis-data/load`. #### `POST /summaries/collections` Lists named collections and counts. This is the inexpensive global discovery route. Pass `collection_id` with `include_members: true` to expand one collection and receive its compact members. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/summaries/collections \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{"cache_dir": "/Users/me/JumperAnalysis"}' ``` #### `POST /summaries/list` Lists named analyses and one-line summaries for selected `media_paths` or `hash_strs`. This is not global discovery: omitting both selectors returns an empty `summaries` array. Each result includes a stable `summary_ref` in the form `:`. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/summaries/list \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "media_paths": ["/Videos/episode-03.mov"] }' ``` #### `POST /summaries/overview` Pass `cache_dir` and preferably the `summary_ref` returned by discovery. The response contains the selected root text, `short_summary`, and bounded previews of its immediate children. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/summaries/overview \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "summary_ref": "1e09e4953de0471b:story-pass" }' ``` You may use `path` or `hash_str` with an optional `analysis_id` instead, but `summary_ref` uniquely identifies both the media and named analysis. #### `POST /summaries/node` Pass the same selector plus `node_id` to retrieve that node and its immediate children. Keep `summary_ref` on every node request because node IDs are local to one analysis. Set `include_evidence: true` on a leaf to receive compact sampled-frame references, transcript excerpts, speaker names, named people, and attribution hints. Image bytes and embeddings are not returned. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/summaries/node \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "summary_ref": "1e09e4953de0471b:story-pass", "node_id": "leaf-0042", "include_evidence": true }' ``` Every node includes a half-open range on Jumper's 1 FPS grid. Pass its `search_scope` unchanged as `segments_to_frame_indices` to a visual search: ```json theme={null} { "search_scope": { "1e09e4953de0471b": [0, 300] } } ``` Nodes may also include bounded `verification_hints` with the affected range, supporting evidence IDs, and a suggested source check. *** ### Analysis Data Management Before you can search, the analysis data needs to be loaded into memory. There are two approaches: #### `POST /analysis-data/load` Loads **all** analysis data from the folder into memory — visual embeddings, people metadata, and transcriptions. Best when you want to search across everything. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/analysis-data/load \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{"cache_dir": "/Users/me/JumperAnalysis"}' ``` **Response:** ```json theme={null} {"message": "Analysis data loaded in 0.45s"} ``` #### `POST /analysis-data/load-for-media` Loads visual analysis data for **specific video/image files** only. More efficient when working with a subset. Skips files already in memory. This endpoint does not load transcriptions. Use `/analysis-data/load` to load everything, or `/analysis-data/load-transcriptions` for transcript-only workflows. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/analysis-data/load-for-media \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "media_paths": ["/Videos/interview.mp4"] }' ``` **Response:** ```json theme={null} {"message": "Loaded analysis data for 1 files in 0.12s"} ``` #### `POST /analysis-data/load-transcriptions` Loads transcription data into memory separately. This is useful if you only need transcript search and don't want to load visual analysis data. Transcriptions are also loaded automatically by `/analysis-data/load`. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/analysis-data/load-transcriptions \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{"cache_dir": "/Users/me/JumperAnalysis"}' ``` **Response:** ```json theme={null} {"message": "Loaded 123 transcriptions in 0.09s"} ``` *** ### Metadata Filters #### `POST /metadata/facets` Returns curated metadata filter facets and coverage for a searchable scope. Call this when you need to render metadata filter options, then pass selected filters to search as `metadata_filter_request`. For `search_all: true` or `scope.mode: "global"`, the response is scoped to the backend's loaded searchable media for the requested `media_type` (`visual`, `speech`, or `any`), not every row in the local metadata database. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/metadata/facets \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "media_type": "visual", "search_all": true, "filters": [] }' ``` **Path-scoped request with known hashes:** ```json theme={null} { "cache_dir": "/Users/me/JumperAnalysis", "scope": { "mode": "paths", "media_type": "visual", "media_paths": ["/Videos/interview.mp4"], "hash_strs": ["1e09e4953de0471b"], "expected_count": 1 }, "filters": [] } ``` `media_paths` and `hash_strs` are index-aligned. If you omit `scope`, Jumper derives it from `search_all`, `media_type`, `media_paths`, `hash_strs`, and `expected_count`. **Response:** ```json theme={null} { "success": true, "coverage": { "scope_count": 583, "indexed_count": 423, "missing_count": 160 }, "active_filter_count": 0, "warning": "Metadata available for 423 of 583 media included in search", "facets": [ { "id": "video.codec", "label": "Codec", "group": "Video", "path": ["Video", "Codec"], "kind": "single", "options": [ {"value": "red", "label": "RED", "count": 5}, {"value": "h264", "label": "H.264", "count": 42} ] }, { "id": "video.bitrate_range", "label": "Video bitrate", "group": "Video", "path": ["Video", "Video bitrate"], "kind": "single", "options": [ {"value": "10-50mbps", "label": "10-50 Mbps", "count": 81} ] } ] } ``` Facet IDs and option values are intentionally stable API values. Option labels are for display. The facet list is curated; low-value raw fields such as exact duration seconds, exact frame counts, codec levels, and noisy object-like timecode values are omitted. **Using selected filters in search:** ```json theme={null} { "query": "dog on a beach", "cache_dir": "/Users/me/JumperAnalysis", "search_all": true, "metadata_filter_request": { "filters": [ {"facet_id": "video.codec", "operator": "is_any_of", "values": ["red"]}, {"facet_id": "video.bitrate_range", "operator": "is_any_of", "values": ["50-100mbps"]} ] } } ``` Supported operators are `is_any_of`, `is_not`, `include_any_of`, `include_all_of`, `exclude_any_of`, `exclude_all_of`, `before`, `after`, `greater_than`, and `less_than`. *** ### Search All search endpoints require analysis data to be loaded into memory first (see above). The visual search endpoints (`/search/text`, `/search/image`, `/search/frame`) return the same match structure and order results best-first. Jumper does not return similarity scores in the response payload. The optional `exclude` field is a soft ranking signal, not a hard filter. `metadata_filter_request` applies hard metadata filters from `/metadata/facets`. `segments_to_frame_indices` applies one or more half-open per-media ranges on the 1 FPS analysis grid and can receive a Summary node's `search_scope` unchanged. #### `POST /search/text` Semantic visual search — describe what you're looking for in plain language. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/search/text \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "query": "dog on a beach", "exclude": ["water", "swimming pool"], "cache_dir": "/Users/me/JumperAnalysis", "media_paths": ["/Videos/interview.mp4"], "max_results": 10 }' ``` **Response:** ```json theme={null} { "matches": [ { "frame_idx": "76", "timestamp": "00:01:16", "image": "/9j/4AAQSkZJRgABAQAAAQABAAD...", "scene_start_timestamp": "00:01:10", "scene_end_timestamp": "00:01:19", "original_index": 0, "hash_str": "1e09e4953de0471b", "video_path": "/Videos/interview.mp4" }, { "frame_idx": "107", "timestamp": "00:01:47", "image": "/9j/4AAQSkZJRgABAQAAAQABAAD...", "scene_start_timestamp": "00:01:43", "scene_end_timestamp": "00:01:52", "original_index": 1, "hash_str": "1e09e4953de0471b", "video_path": "/Videos/interview.mp4" } ] } ``` `frame_idx` is the frame number on the 1-FPS embedding grid, returned as a string. `original_index` is the result's position in the underlying ranking before per-video grouping. **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `query` | string | required | What you're looking for | | `cache_dir` | string | required | Analysis data folder | | `media_paths` | string\[] | `[]` | Restrict to these files | | `max_results` | int | 50 | Maximum matches to return | | `search_all` | bool | false | Search all loaded media (ignores `media_paths`) | | `text_weight` | number | 1 | Text similarity weight (advanced) | | `exclude` | string\[] | `[]` | Visual concepts to softly push down in the ranking | | `people_filter` | object\[] | `[]` | Only show results containing specific people | | `people_filter_mode` | string | `and` | `"and"` requires all selected people in the same frame; `"or"` matches any selected person | | `metadata_filter_request` | object | optional | Metadata filters from `/metadata/facets`. If `scope` is omitted, Jumper derives it from `search_all` and `media_paths`. | | `segments_to_frame_indices` | object | optional | Selected media path/hash to `[start_frame, end_frame]` or a list of ranges; each end is exclusive. | **Filtering by people:** If you've run face clustering, you can restrict results to frames containing specific people: ```json theme={null} { "query": "waving hands", "cache_dir": "/Users/me/JumperAnalysis", "media_paths": ["/Videos/interview.mp4"], "people_filter_mode": "and", "people_filter": [ {"cluster_job_name": "Interview Faces", "person_name": "Anna"}, {"cluster_job_name": "Interview Faces", "person_name": "David"} ] } ``` #### `POST /search/image` Find moments visually similar to a reference image. Optionally combine with a text query. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/search/image \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "image_path": "/Images/reference.jpg", "cache_dir": "/Users/me/JumperAnalysis", "media_paths": ["/Videos/interview.mp4"], "max_results": 10 }' ``` **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `image_path` | string | required | Path to the reference image | | `query` | string | optional | Text query to combine with the image | | `cache_dir` | string | required | Analysis data folder | | `media_paths` | string\[] | `[]` | Restrict to these files | | `max_results` | int | 50 | Maximum matches to return | | `search_all` | bool | false | Search all loaded media | | `exclude` | string\[] | `[]` | Visual concepts to softly push down in the ranking. Requires `query`. | | `metadata_filter_request` | object | optional | Metadata filters from `/metadata/facets` | | `segments_to_frame_indices` | object | optional | Selected media path/hash to one or more half-open 1 FPS frame ranges. | #### `POST /search/frame` Find moments similar to a specific frame in a video — a "find more like this" search. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/search/frame \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "media_path": "/Videos/interview.mp4", "time_seconds": 38, "cache_dir": "/Users/me/JumperAnalysis", "media_paths": ["/Videos/interview.mp4"], "max_results": 10 }' ``` **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `media_path` | string | required | Video to extract the reference frame from | | `time_seconds` | number | required | Timestamp in seconds | | `query` | string | optional | Text query to combine with the frame | | `cache_dir` | string | required | Analysis data folder | | `media_paths` | string\[] | `[]` | Restrict to these files | | `max_results` | int | 50 | Maximum matches to return | | `search_all` | bool | false | Search all loaded media | | `exclude` | string\[] | `[]` | Visual concepts to softly push down in the ranking. Requires `query`. | | `metadata_filter_request` | object | optional | Metadata filters from `/metadata/facets` | | `segments_to_frame_indices` | object | optional | Selected media path/hash to one or more half-open 1 FPS frame ranges. | #### `POST /search/transcript` Search through loaded transcriptions for segments containing a query string. Uses case-insensitive substring matching. To search only within one named transcript speaker, pass `speaker` or `speaker_name`. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/search/transcript \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "query": "hello world", "cache_dir": "/Users/me/JumperAnalysis", "speaker_name": "Anna", "max_results": 10 }' ``` **Response:** ```json theme={null} { "matches": [ { "media_path": "/Videos/interview.mp4", "hash_str": "1e09e4953de0471b", "start_seconds": 12.5, "end_seconds": 15.2, "text": "And she said hello world to the audience", "start_timestamp": "00:00:12", "end_timestamp": "00:00:15", "speaker": "SPEAKER_00", "speaker_name": "Anna" } ] } ``` Speaker filtering uses transcript speaker display names stored in transcription metadata. It is separate from face-clustering people names and does not use `people_filter`. **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `query` | string | required | Text to search for (case-insensitive substring match) | | `cache_dir` | string | required | Analysis data folder | | `media_paths` | string\[] | `[]` | Restrict to these files | | `max_results` | int | 50 | Maximum matches to return | | `search_all` | bool | true | Search across all loaded transcriptions | | `speaker` | string | optional | Restrict results to a named transcript speaker | | `speaker_name` | string | optional | Alias for `speaker` | | `metadata_filter_request` | object | optional | Metadata filters from `/metadata/facets`. Defaults to a `speech` scope when omitted. | *** ### Transcriptions #### `POST /transcriptions` Returns speech transcriptions for media files that have been transcribed via `/analyze`. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/transcriptions \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "media_paths": ["/Audio/voiceover.mp3", "/Videos/interview.mp4"] }' ``` **Response:** ```json theme={null} { "transcriptions": { "/Audio/voiceover.mp3": [ [0.0, " One, two, three, testing.", 2.52, "/Audio/voiceover.mp3"] ], "/Videos/interview.mp4": [ [0.0, " Welcome to today's discussion.", 3.84, "/Videos/interview.mp4"], [3.84, " We'll be talking about...", 7.12, "/Videos/interview.mp4"] ] } } ``` Each segment is an array: `[start_seconds, text, end_seconds, media_path]` #### `POST /transcriptions/range` Returns only transcript segments overlapping one half-open source time range. Prefer `hash_str` so Jumper can read the cached transcript without touching the source media file. This is the bounded follow-up used by Summary `verification_hints` that recommend reading transcript context. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/transcriptions/range \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "hash_str": "1e09e4953de0471b", "start_seconds": 120, "end_seconds": 180, "max_segments": 120 }' ``` Responses are bounded. When `truncated` is `true`, repeat the same range with the returned `next_after_segment_index` as `after_segment_index`. *** ### Thumbnails #### `POST /thumbnails` Get base64-encoded JPEG thumbnail images for specific media/timestamp pairs. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/thumbnails \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "requests": [ {"media_path": "/Videos/interview.mp4", "time_seconds": 38}, {"media_path": "/Videos/interview.mp4", "time_seconds": 76} ] }' ``` **Response:** ```json theme={null} { "thumbnails": [ {"thumbnail": "/9j/4AAQSkZJRg..."}, {"thumbnail": "/9j/4AAQSkZJRg..."} ] } ``` Each `thumbnail` is a base64-encoded JPEG string, or `null` for audio files. #### `POST /thumbnails/scene` Get a strip of thumbnails spanning a time range. Useful for timeline scrubbers. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/thumbnails/scene \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "media_path": "/Videos/interview.mp4", "start_time": "00:01:00", "end_time": "00:02:00", "hash_str": "1e09e4953de0471b" }' ``` **Response:** ```json theme={null} { "scene_thumbnails": [ ["/9j/4AAQSkZJRg...", "00:01:00"], ["/9j/4AAQSkZJRg...", "00:01:01"], ["/9j/4AAQSkZJRg...", "00:01:02"] ] } ``` Each entry is `[base64_jpeg, timestamp]`. For ranges longer than 100 seconds, Jumper samples 100 evenly-spaced frames instead of one per second. *** ### Face Clustering Jumper detects faces across video frames and automatically groups them by identity. These endpoints let you inspect, name, and refine those groups. #### `GET /faces/clusters` Lists all clustering jobs and their statistics. **Example request:** ```bash theme={null} curl -H "X-License-Key: YOUR_KEY" \ "http://localhost:6699/api/v1/faces/clusters?cache_dir=/Users/me/JumperAnalysis" ``` **Response:** ```json theme={null} { "cluster_jobs": ["Interview Faces"], "jobs": [ { "name": "Interview Faces", "total_entries": 206, "num_clusters": 2, "noise_entries": 3, "cluster_ids": ["a1b2c3d4-...", "e5f6a7b8-..."], "face_storage_version": 2, "media_hashes": ["1e09e4953de0471b"] } ] } ``` `face_storage_version` reports the on-disk face storage format for the job. Newer jobs use the packed format; older legacy jobs may not be mutable for reclustering or merges. #### `POST /faces/clusters/samples` Get sample face thumbnail images for each cluster. Useful for building a "who is this?" UI. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/faces/clusters/samples \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "cluster_job_name": "Interview Faces", "limit_per_cluster": 4, "max_clusters": 50 }' ``` **Response:** ```json theme={null} { "cluster_job_name": "Interview Faces", "num_clusters": 2, "num_clusters_after_filter": 2, "total_entries": 206, "clusters": [ { "cluster_id": "a1b2c3d4-...", "name": "Rodrigo", "size": 120, "sample_faces": ["/9j/4AAQ...", "/9j/4AAQ...", "/9j/4AAQ...", "/9j/4AAQ..."] }, { "cluster_id": "e5f6a7b8-...", "name": "Carlos", "size": 83, "sample_faces": ["/9j/4AAQ...", "/9j/4AAQ...", "/9j/4AAQ...", "/9j/4AAQ..."] } ] } ``` **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `cache_dir` | string | required | Analysis data folder | | `cluster_job_name` | string | required | Which clustering job to query | | `limit_per_cluster` | int | 12 | Max face thumbnails per cluster | | `min_cluster_size` | int | 1 | Skip clusters smaller than this | | `max_cluster_size` | int | 1000000000 | Skip clusters larger than this | | `max_clusters` | int | 100 | Maximum clusters to return | | `include_noise` | bool | false | Include unassigned faces in response | #### `POST /faces/clusters/faces` Get paginated face images for specific cluster(s). For browsing all faces in a cluster. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/faces/clusters/faces \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "cluster_job_name": "Interview Faces", "cluster_id": "a1b2c3d4-...", "limit": 100, "offset": 0 }' ``` **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `cluster_id` | string | - | Single cluster to query | | `cluster_ids` | string\[] | - | Multiple clusters (overrides `cluster_id`) | | `limit` | int | 500 | Page size (max 2000) | | `offset` | int | 0 | Skip this many entries | #### `PUT /faces/clusters/names` Assign human-readable names to clusters. **Example request:** ```bash theme={null} curl -X PUT http://localhost:6699/api/v1/faces/clusters/names \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "cluster_job_name": "Interview Faces", "assignments": [ {"cluster_id": "a1b2c3d4-...", "name": "Rodrigo"}, {"cluster_id": "e5f6a7b8-...", "name": "Carlos"} ] }' ``` **Response:** ```json theme={null} { "updated": 2, "changes": { "a1b2c3d4-...": "Rodrigo", "e5f6a7b8-...": "Carlos" } } ``` #### `POST /faces/recluster` Re-runs face clustering with different parameters. Useful for tuning how aggressively faces are grouped. Runs asynchronously. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/faces/recluster \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "cluster_job_name": "Interview Faces", "eps": 0.55, "min_samples": 3 }' ``` **Response (202):** ```json theme={null} { "message": "Re-clustering started", "task_id": "f1e2d3c4-..." } ``` **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `eps` | float | 0.48 | Clustering sensitivity — lower means stricter grouping (fewer, purer clusters) | | `min_samples` | int | 5 | Minimum faces needed to form a cluster | | `auto_detect_params` | bool | false | Let Jumper pick eps/min\_samples automatically | | `clear_names` | bool | false | Clear all existing cluster names | #### `POST /faces/clusters/modify` Merge clusters or move individual faces between clusters. Useful for correcting mistakes. **Example — merge two clusters:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/faces/clusters/modify \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "cluster_job_name": "Interview Faces", "merges": [ { "cluster_ids": ["small-cluster-id", "target-cluster-id"], "target_cluster_id": "target-cluster-id" } ], "moves": [] }' ``` *** ### Watch Folders Watch folders let Jumper automatically analyze new media files as they appear in a directory. #### `GET /watch-folders` Lists all configured watch folders and the background service status. ```bash theme={null} curl -H "X-License-Key: YOUR_KEY" http://localhost:6699/api/v1/watch-folders ``` **Response:** ```json theme={null} { "watch_folders": [ { "id": "wf-abc123", "folder_path": "/Volumes/Media/Ingest", "enabled": true, "enable_visual_analysis": true, "enable_audio_analysis": true, "enable_face_analysis": false, "audio_language": "english", "cluster_job_name": null, "face_eps": 0.48, "face_min_samples": 5, "cache_dir": "/Users/me/JumperAnalysis", "excluded_extensions": [".jpg", ".jpeg"], "excluded_filename_globs": ["*_a04.mxf"], "excluded_folder_globs": ["finished", "client_a/finished_*"], "created_at": 1707840000, "last_poll_time": 1707840060, "files_analyzed_count": 24 } ], "service_status": { "state": "running", "current_folder": null, "current_file": null, "files_pending": 0, "files_processed_this_session": 24, "last_error": null, "paused_until": null, "folder_stats": {} } } ``` #### `POST /watch-folders` Add a new watch folder. The folder must exist on disk. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/watch-folders \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "folder_path": "/Volumes/Media/Ingest", "cache_dir": "/Users/me/JumperAnalysis", "enabled": true, "enable_visual_analysis": true, "enable_audio_analysis": true, "audio_language": "english", "excluded_extensions": [".jpg", ".jpeg"], "excluded_filename_globs": ["*_a04.mxf"], "excluded_folder_globs": ["finished", "client_a/finished_*"] }' ``` **Response (201):** ```json theme={null} { "message": "Watch folder added: /Volumes/Media/Ingest", "watch_folder": { ... } } ``` **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `folder_path` | string | required | Absolute path to watch | | `cache_dir` | string | optional | Where to store analysis data | | `enabled` | bool | true | Start watching immediately | | `enable_visual_analysis` | bool | true | Analyze visual content for searching | | `enable_audio_analysis` | bool | false | Transcribe audio | | `enable_face_analysis` | bool | false | Detect and cluster faces | | `audio_language` | string | "english" | Language hint for transcription | | `cluster_job_name` | string | - | Required if face analysis is enabled | | `face_eps` | float | 0.48 | Clustering sensitivity for face grouping | | `face_min_samples` | int | 5 | Minimum faces needed to form a cluster | | `excluded_extensions` | array\[string] | `[]` | File extensions to skip; normalized to lowercase with a leading dot | | `excluded_filename_globs` | array\[string] | `[]` | Filename-only glob patterns to skip, matched case-insensitively | | `excluded_folder_globs` | array\[string] | `[]` | Folder glob patterns to skip, matched case-insensitively under the watched folder | `excluded_filename_globs` apply to the basename only, not the relative or absolute path. `excluded_folder_globs` entries without a path separator match any folder name; for example, `finished` skips files inside any folder named `finished` or `Finished`. Entries with `/` or `\` match relative folder paths under the watched folder; for example, `client_a/finished_*` skips matching folders under `client_a` only. Backslashes are normalized to `/`. Path patterns match segment by segment, so `*/folder2/finished` matches one parent folder above `folder2`, while `folder2/finished` matches only from the watch-folder root. #### `PUT /watch-folders/{id}` Update settings for an existing watch folder. Only include the fields you want to change. ```bash theme={null} curl -X PUT http://localhost:6699/api/v1/watch-folders/wf-abc123 \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{"enabled": false, "excluded_extensions": [], "excluded_filename_globs": ["*_proxy.mov"], "excluded_folder_globs": ["finished", "client_a/finished_*"]}' ``` #### `DELETE /watch-folders/{id}` Remove a watch folder. Does not delete any analysis data. ```bash theme={null} curl -X DELETE http://localhost:6699/api/v1/watch-folders/wf-abc123 \ -H "X-License-Key: YOUR_KEY" ``` #### `POST /watch-folders/service/start` Start the background service that monitors watch folders. This uses the enabled watch-folder configuration already stored in settings; it does not require prior UI interaction in the current session. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/watch-folders/service/start \ -H "X-License-Key: YOUR_KEY" ``` #### `POST /watch-folders/service/stop` Stop the background service. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/watch-folders/service/stop \ -H "X-License-Key: YOUR_KEY" ``` #### `GET /watch-folders/service/status` Check if the service is running. ```bash theme={null} curl -H "X-License-Key: YOUR_KEY" \ http://localhost:6699/api/v1/watch-folders/service/status ``` **Response:** ```json theme={null} { "state": "running", "current_folder": null, "current_file": null, "files_pending": 0, "files_processed_this_session": 24, "last_error": null, "paused_until": null, "folder_stats": {} } ``` *** ### Cache Paths #### `POST /cache-paths` Get the visual and audio cache folder paths for a specific media file. Useful for inspecting or managing analysis data on disk. ```bash theme={null} curl -X POST http://localhost:6699/api/v1/cache-paths \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "cache_dir": "/Users/me/JumperAnalysis", "media_path": "/Videos/interview.mp4" }' ``` **Response:** ```json theme={null} { "video_cache_path": "/Users/me/JumperAnalysis/1e09e4953de0471b", "audio_cache_path": "/Users/me/JumperAnalysis/1e09e4953de0471b_audio", "hash_str": "1e09e4953de0471b" } ``` Paths are `null` if the corresponding analysis hasn't been run yet. *** ### Export #### `POST /export/clips` Export trimmed video clips to a folder using ffmpeg. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/export/clips \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "clips": [ { "source_path": "/Videos/interview.mp4", "start_seconds": 10, "end_seconds": 25 }, { "source_path": "/Videos/interview.mp4", "start_seconds": 60, "end_seconds": 90, "subfolder": "highlights" } ], "output_dir": "/Users/me/Exports", "copy_codec": true }' ``` **Response:** ```json theme={null} { "results": [ {"success": true, "output_path": "/Users/me/Exports/interview_10-25.mp4"}, {"success": true, "output_path": "/Users/me/Exports/highlights/interview_60-90.mp4"} ], "summary": "2/2 clips exported successfully" } ``` **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `clips` | object\[] | required | Array of clip definitions | | `clips[].source_path` | string | required | Source media file path | | `clips[].start_seconds` | number | required | Start time in seconds | | `clips[].end_seconds` | number | required | End time in seconds | | `clips[].subfolder` | string | optional | Subfolder within output\_dir | | `output_dir` | string | required | Directory to write clips to | | `copy_codec` | bool | true | Stream copy (fast, no re-encode) | #### `POST /export/premiere-xml` Generate a Premiere Pro compatible XML sequence file (XMEML v4). Can be imported into Premiere Pro, DaVinci Resolve, Avid, and other NLEs. **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/export/premiere-xml \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "sequence_name": "Interview Highlights", "clips": [ {"source_path": "/Videos/interview.mp4", "start_seconds": 10, "end_seconds": 25}, {"source_path": "/Videos/interview.mp4", "start_seconds": 60, "end_seconds": 90} ], "output_path": "/Users/me/Exports/highlights.xml", "timebase": 24 }' ``` **Response:** ```json theme={null} { "output_path": "/Users/me/Exports/highlights.xml", "clip_count": 2, "total_duration_seconds": 45.0 } ``` **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `sequence_name` | string | "Untitled Sequence" | Name of the sequence in the NLE | | `clips` | object\[] | required | Array of clip definitions | | `clips[].source_path` | string | required | Source media file path | | `clips[].start_seconds` | number | required | Start time in seconds | | `clips[].end_seconds` | number | required | End time in seconds | | `output_path` | string | required | Where to write the XML file | | `timebase` | int | 24 | Sequence frame rate (e.g. 24, 25, 30) | #### `POST /export/transcript` Export transcript segments to a file (TXT, CSV, DOCX, or PDF). **Example request:** ```bash theme={null} curl -X POST http://localhost:6699/api/v1/export/transcript \ -H "X-License-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "segments": [ [0.32, "Hello world.", 5.84], [5.84, "Another line.", 11.20] ], "format": "txt", "display_name": "My Transcript", "output_path": "/Users/me/Exports/transcript.txt" }' ``` **Response:** ```json theme={null} { "output_path": "/Users/me/Exports/transcript.txt", "format": "txt", "row_count": 2 } ``` **Parameters:** | Parameter | Type | Default | Description | | - | - | - | - | | `segments` | array | required | List of `[start_seconds, text, end_seconds]` arrays | | `format` | string | `"txt"` | Export format: `txt`, `csv`, `docx`, `pdf` | | `display_name` | string | `"Transcript"` | Name shown in header/filename | | `output_path` | string | `~/Desktop/{display_name}.{format}` | Destination file path | | `include_silences` | bool | `true` | Include silence gap rows between segments | *** ## Error Format All errors follow the same structure: ```json theme={null} {"error": "Description of what went wrong"} ``` Common status codes: | Code | Meaning | | - | - | | `400` | Bad request (missing or invalid parameters) | | `401` | No license key provided | | `403` | Not a Pro license | | `404` | Resource not found (e.g. watch folder ID) | | `500` | Server error | | `503` | Models still loading — retry shortly | *** ## SocketIO Progress Tracking For long-running operations (`/analyze`, `/faces/recluster`), connect to the SocketIO server at `http://localhost:6699` and join the room matching the returned `task_id`. In Socket.IO terms, emit `join` with the returned `task_id`, then listen for `progress`. **Event: `progress`** ```json theme={null} { "progress": 45.5, "video_path": "/Videos/interview.mp4", "done": false, "type": "video" } ``` Common fields: * `progress` — numeric percentage * `video_path` — the file currently being processed, or `null` for some clustering updates * `done` — `true` when the task is complete * `type` — `"video"` for visual analysis, `"speech"` for transcription * `is_cluster_job` — present for face-clustering progress * `cluster_job_name` — present for face-clustering progress * `cluster_media_hashes` — present on some clustering completion events # Search by reference image Source: https://docs.getjumper.io/api-reference/search/search-by-reference-image /api-reference/openapi-v1.yaml post /search/image Finds moments visually similar to a reference image. Optionally combine with a text query to refine results. Results are ordered best-first. # Search by text query Source: https://docs.getjumper.io/api-reference/search/search-by-text-query /api-reference/openapi-v1.yaml post /search/text Semantic visual search — finds moments in analyzed media that match a natural-language description. Analysis data must be loaded into memory first. Results are ordered best-first, but Jumper does not return similarity scores. # Search by video frame Source: https://docs.getjumper.io/api-reference/search/search-by-video-frame /api-reference/openapi-v1.yaml post /search/frame Extracts a frame at the given timestamp from a video, then finds visually similar moments across all loaded media. Useful for "find more like this" features. Results are ordered best-first. # Search transcriptions by text Source: https://docs.getjumper.io/api-reference/search/search-transcriptions-by-text /api-reference/openapi-v1.yaml post /search/transcript Searches through loaded speech transcriptions for segments containing the query string. Uses case-insensitive substring matching. Transcriptions must be loaded into memory first (via `/analysis-data/load` or `/analysis-data/load-transcriptions`). Optionally filter to transcript segments assigned to a named speaker by passing `speaker` or `speaker_name`. Speaker filtering uses transcript speaker names, not face-clustering person names. # API Spec Files Source: https://docs.getjumper.io/api-reference/spec-files Raw download links for the Jumper Public API v1 OpenAPI YAML, OpenAPI JSON, and Markdown endpoint reference. Use these links when you want the raw API contract or prose reference without browsing generated endpoint pages. Machine-readable discovery: * Raw OpenAPI YAML: `/api-reference/openapi-v1.yaml` * Raw OpenAPI JSON: `/api-reference/openapi.json` * Markdown guide: `/api-reference/public-api-v1.md` If a user gives you a Jumper docs URL and asks for API details, fetch `/llms.txt` first when available, then download the raw OpenAPI YAML or JSON for schemas. Use the Markdown guide for examples and workflow notes. Raw OpenAPI 3.0 source for Jumper Public API v1. Raw JSON mirror of the OpenAPI contract. Markdown export with curl examples and behavior notes. ## Recommended use | Resource | Best for | | - | - | | Raw OpenAPI YAML | Endpoint discovery, request schemas, response schemas, and generated clients | | Raw OpenAPI JSON | Tools that prefer JSON over YAML | | Markdown reference | Workflow guidance, examples, status-code notes, and implementation behavior | # Drill into one hierarchical summary node Source: https://docs.getjumper.io/api-reference/summaries/drill-into-one-hierarchical-summary-node /api-reference/openapi-v1.yaml post /summaries/node Returns one selected node and its immediate children. Node IDs are local to an analysis, so keep summary_ref on every request. Leaf evidence is included only when requested. # List hierarchical summary collections Source: https://docs.getjumper.io/api-reference/summaries/list-hierarchical-summary-collections /api-reference/openapi-v1.yaml post /summaries/collections Returns compact collection metadata and counts without enumerating members by default. Pass collection_id with include_members=true to return every compact registry member of only that collection, without loading summary text or applying the legacy 500-member cap. # List named summary analyses for media Source: https://docs.getjumper.io/api-reference/summaries/list-named-summary-analyses-for-media /api-reference/openapi-v1.yaml post /summaries/list Lists selected media only. With neither media_paths nor hash_strs, returns an empty summaries array. Reads persisted artifacts directly; analysis data does not need to be loaded. # Read a compact whole-media summary Source: https://docs.getjumper.io/api-reference/summaries/read-a-compact-whole-media-summary /api-reference/openapi-v1.yaml post /summaries/overview Returns one selected root node plus bounded previews of its immediate children. Reads persisted artifacts directly; analysis data does not need to be loaded. # Get thumbnails at specific timestamps Source: https://docs.getjumper.io/api-reference/thumbnails/get-thumbnails-at-specific-timestamps /api-reference/openapi-v1.yaml post /thumbnails Returns base64-encoded JPEG thumbnails for the requested media/timestamp pairs. # Get thumbnails for a time range Source: https://docs.getjumper.io/api-reference/thumbnails/get-thumbnails-for-a-time-range /api-reference/openapi-v1.yaml post /thumbnails/scene Returns a series of thumbnails spanning a time range in a video. Useful for building timeline scrubbers or scene overview strips. # Get a bounded transcript range Source: https://docs.getjumper.io/api-reference/transcriptions/get-a-bounded-transcript-range /api-reference/openapi-v1.yaml post /transcriptions/range Returns transcript segments that overlap one half-open source range (`segment_start < end_seconds` and `segment_end > start_seconds`). Pass `hash_str` to avoid reading the source media path. Responses are bounded; when `truncated` is true, repeat the same range with the returned `next_after_segment_index` as `after_segment_index`. # Get transcriptions Source: https://docs.getjumper.io/api-reference/transcriptions/get-transcriptions /api-reference/openapi-v1.yaml post /transcriptions Returns cached speech transcriptions for the given media files. Files must have been transcribed via the `/analyze` endpoint first. # Get cache folder paths for a media file Source: https://docs.getjumper.io/api-reference/utilities/get-cache-folder-paths-for-a-media-file /api-reference/openapi-v1.yaml post /cache-paths Returns the visual and audio cache folder paths for a specific media file. Useful for inspecting or managing analysis data on disk. # Create a watch folder Source: https://docs.getjumper.io/api-reference/watch-folders/create-a-watch-folder /api-reference/openapi-v1.yaml post /watch-folders Adds a new folder to be automatically analyzed when new media files appear. The folder must exist on disk. Exclusion glob patterns are matched against the filename only, not the full path. # Delete a watch folder Source: https://docs.getjumper.io/api-reference/watch-folders/delete-a-watch-folder /api-reference/openapi-v1.yaml delete /watch-folders/{watch_folder_id} Removes a watch folder from the configuration. Does not delete analysis data. # Get watch folder service status Source: https://docs.getjumper.io/api-reference/watch-folders/get-watch-folder-service-status /api-reference/openapi-v1.yaml get /watch-folders/service/status Returns whether the background service is running and its current state. # List watch folders Source: https://docs.getjumper.io/api-reference/watch-folders/list-watch-folders /api-reference/openapi-v1.yaml get /watch-folders Returns all configured watch folders and the background service status. # Start the watch folder service Source: https://docs.getjumper.io/api-reference/watch-folders/start-the-watch-folder-service /api-reference/openapi-v1.yaml post /watch-folders/service/start Starts the background service that monitors watch folders for new media. The service uses the enabled watch-folder configuration already persisted in settings. # Stop the watch folder service Source: https://docs.getjumper.io/api-reference/watch-folders/stop-the-watch-folder-service /api-reference/openapi-v1.yaml post /watch-folders/service/stop Stops the background watch folder monitoring service. # Update a watch folder Source: https://docs.getjumper.io/api-reference/watch-folders/update-a-watch-folder /api-reference/openapi-v1.yaml put /watch-folders/{watch_folder_id} Modify settings for an existing watch folder. Only include fields you want to change. Filename exclusion glob patterns are matched against the filename only, not the full path. Folder exclusion glob patterns without slashes match folder names; patterns with slashes match relative folder paths segment by segment. # Known Issues Source: https://docs.getjumper.io/common-issues/known-issues A list of known issues with Jumper. * Jumper currently doesn't support Merge Clips in Adobe Premiere due to limitations in the Adobe API - sorry! * Claude Cowork currently does not reliably pick up the Jumper MCP integration. For agentic editing with Jumper, use Claude Code Desktop or Claude Code CLI instead. # Panel won't open Source: https://docs.getjumper.io/common-issues/panel-not-opening If you have trouble opening the Jumper panel, select your NLE for platform-specific troubleshooting. Select your editing software for troubleshooting steps: * **[Adobe Premiere Pro](/NLE/premiere/premiere-panel-not-opening)** — Jumper not showing in the Extension menu * **[Avid Media Composer](/NLE/avid/avid-troubleshooting#panel-wont-open)** — Jumper not showing in Tools or Extensions menu # Unable to search Source: https://docs.getjumper.io/common-issues/select-media-before If Jumper won't let you search there can be a few different things to check ## Is the media analyzed? You first need to [analyze your footage](/core-concepts/processing) before it becomes searchable. The middle column selects files for visual analysis, and the right column selects files for audio transcription. Press the big Process selection button at the bottom of Jumper's media table. After that, use the left-column checkbox to include files that were analyzed in your searches. You can confirm this because the checkboxes for visual and/or audio processing turn green. ## Is the license correctly entered? Make sure you've entered the license key correctly. The License key input should have a green border and a green tick. ## Included in search? The first column with checkboxes in the [Media tab](/interface/media-tab) controls whether to include or exclude the media files when you search. Check to see if the media you want to search in is checked. # Jumper compatibility and system requirements Source: https://docs.getjumper.io/compatibility Check Jumper compatibility and system requirements for Adobe Premiere Pro, Final Cut Pro, DaVinci Resolve Studio, and Avid Media Composer. ## Overview Jumper runs on macOS and Windows and integrates with Adobe Premiere Pro, Final Cut Pro, DaVinci Resolve Studio, and Avid Media Composer. Final Cut Pro is macOS-only; the other supported editors are available with Jumper on both operating systems. | Editing Software | macOS | Windows | | :- | :-: | :-: | | [**Adobe Premiere Pro**](/NLE/premiere/premiere-index) | | | | [**Final Cut Pro**](/NLE/fcp/fcp-index) | | | | [**DaVinci Resolve Studio**](/NLE/resolve/resolve-index) | | | | [**Avid Media Composer**](/NLE/avid/avid-index) | | | ## Operating Systems ### macOS | | | | - | - | | **Minimum OS** | macOS Sonoma 14.0 or later (Metal 3.1 required) | | **Recommended** | macOS 26 | | **Hardware** | Apple Silicon Mac or Intel Mac | ### Windows | | | | - | - | | **Minimum OS** | Windows 10 or later | | **Hardware** | Windows PC (preferably with NVIDIA GPU) | ## Editing Software Versions | Editing Software | Minimum Version | | :- | :- | | **Adobe Premiere Pro** | v24.0.0 | | **Final Cut Pro** | 10.6.5 | | **DaVinci Resolve** | Studio v19.0.3 (paid version only) | | **Avid Media Composer** | v2023.8 | ## AI agents Jumper integrates with the following AI agents for [agentic editing](/core-concepts/agentic-editing): | AI Agent | macOS | Windows | | :- | :-: | :-: | | **Claude Code Desktop** | | | | **Claude Code CLI** | | | | **OpenAI Codex Desktop** | | | Claude Cowork currently does not reliably pick up the Jumper integration. For Jumper workflows, use Claude Code Desktop or Claude Code CLI. View detailed system requirements, including additional requirements, permissions, and platform-specific notes # Agentic video editing with Jumper Source: https://docs.getjumper.io/core-concepts/agentic-editing Agentic video editing lets compatible AI agents use Jumper to analyze, search, review, and assemble footage through a local MCP server. agentic_editing_hero.png ## How does agentic video editing work? **Agentic video editing** lets AI agents operate Jumper directly—searching footage, retrieving clips, reading or writing supported NLE timelines, and triggering workflow actions—through an MCP server. Jumper integrates with Claude Code Desktop, Claude Code CLI, OpenAI Codex Desktop, Bionic, and LM Studio, so you can give a natural-language task to an agent and have it break the work into steps and execute them. Instead of clicking through searches and exports yourself, you describe what you want in plain language. The agent queries Jumper's backend, orchestrates the workflow, and produces the result (clips, sequences, exports) without you having to perform each step manually. Jumper's [AI video analysis](/core-concepts/ai-video-analysis) gives the agent access to visual, speech, face, and Summary Analysis while Jumper keeps the media processing local. For a product overview, see [AI agents for video editing](https://getjumper.io/ai-agents). New to agentic editing? Start with the step-by-step tutorial. ## What agents can do ### Same as you Agents can use Jumper much like you do through the interface: * **Search visually** across analyzed footage using natural language * **Search transcriptions** for spoken words and phrases * **Retrieve clip segments** with start and end times * **Find similar clips** by text, image, or frame * **Find clips by face recognition** (people search) * **Navigate Summary Analyses** to understand unfamiliar footage before running focused searches * **Trigger workflow actions** such as exporting a sequence to Premiere Pro, Final Cut Pro, DaVinci Resolve, or Avid Media Composer * **Read timelines** from Premiere Pro, DaVinci Resolve, and Avid Media Composer * **Send edited timelines back** to the active NLE project ### Beyond the UI Because the agent orchestrates Jumper programmatically, it can also do things the normal interface does not: * **Export scenes as individual files** to a folder * **Export a set of clips as a sequence** for your editing software (Premiere XML, FCPXML, etc.) The agent combines these capabilities into multi-step workflows that would otherwise require manual repetition. For broad research or unfamiliar footage, [Summary Analysis](/core-concepts/summary-analysis) gives the agent a concise overview first. It can progressively open promising sections, narrow its searches to relevant source ranges, and then verify quotes, identities, and edit points against the underlying evidence. ### Timeline import and export Agents can read the active timeline from Premiere Pro, DaVinci Resolve, or Avid Media Composer, then send an edited version back to the same NLE. This supports round-trip workflows such as: * Pulling a rough cut from the NLE, finding better takes or b-roll for each clip, and updating the timeline * Auditing a sequence against script notes or a shot list * Rebuilding a timeline from search results while preserving structure from the original edit The agent receives timeline metadata (clips, timecodes, track layout) through MCP. Jumper still runs all search and analysis locally. Your footage does not leave your machine. Read my current Premiere timeline, find calmer landscape b-roll for each clip, and update the timeline with the best matches. Worked for 2m 10s Updated the active Premiere sequence with 14 replacement clips. Review the timeline in Premiere before locking the cut. ## Orchestration The agent acts as the orchestrator: you give it a complex task, and it breaks it down into smaller steps and runs them in the right order. The agent decides how to search, filter, and export, then executes the workflow end to end. ## Example use cases Agentic editing can speed up routine media production tasks: * Finding B-roll that matches a script * Pulling every clip of a certain person across a large library * Creating sequences of selects for review or rough cuts * VO + B-roll workflows (e.g. sizzle reels from event footage with a voiceover track) The same pattern applies to many other tasks that involve repeated search, selection, and export steps. Use Jumper to find all shots of Anna smiling, export them as individual files, and also export a sequence to Premiere. Worked for 50s Export finished. The Premiere XML timeline is saved at \~/jumper\_test\_movies/anna\_smiling\_sequence.xml **Sequence:** Anna smiling **Clips:** 20 (\~1:20 total duration) The clips are in \~/jumper\_test\_movies/anna\_smiling\_clips/ In Premiere Pro, use File -> Import and select the XML file. A sequence named "Anna smiling" will be added with all 20 clips in order. Ensure the source media is imported in your project first, or let Premiere relink if paths differ. Use Jumper to cut a sizzle reel from the event footage in /day1\_footage/ with the voiceover sizzle\_reel\_audio.wav. Worked for 1m 15s Export finished. The sizzle reel with synced voiceover has been created. **Sequence file:** \~/day1\_footage/sizzle\_reel\_with\_vo.xml * **Clips:** 12 (cut to match voiceover timing) * **Voiceover:** sizzle\_reel\_audio.wav (synced) Drag it to your timeline to add it to your project. ## Parallel workflows Jumper can serve multiple agent sessions at the same time. As each agent can work on different tasks, you can fire off several jobs in parallel and focus on other work while they complete. ## Skills in agentic video editing Skills are how you encode repeatable editing workflows for the agent. Each skill is a SKILL.md file that defines when the workflow should be used, what steps it runs, and how results should be returned. ### Why skills matter * **Predictable behavior** — Same workflow runs consistently across sessions and across editors. * **Shorter prompts** — Process logic lives in reusable instructions instead of long conversation context. * **Standardized quality** — Teams can enforce naming conventions, export formats, and review checks. * **Specialized workflows** — Complex or domain-specific steps stay out of the general conversation loop. ### What you can customize 1. **Modify shipped skills** — Tune existing workflows for your editorial style (clip length bias, pacing, selection thresholds, export defaults). 2. **Add new skills** — Create workflows for jobs your team repeats often (e.g., social cutdowns, b-roll sequences, interview selects). To learn how to add custom skills, see [Add a custom skill](/guides/add-custom-skill). ## Compatibility Jumper is currently compatible with: * **Claude Code Desktop** * **Claude Code CLI** * **OpenAI Codex Desktop** * **Bionic** * **LM Studio** Claude Cowork currently does not reliably pick up the Jumper integration. For Jumper workflows, use Claude Code Desktop or Claude Code CLI. To connect Jumper to an AI agent, use the **AI Agent** section in the [Settings tab](/interface/settings-tab#ai-agent). Setup is one-click for Claude and Codex. Bionic and LM Studio run models on your own machine. They are set up by hand, not with the install buttons. See [Using Jumper with local LLM agents](/guides/local-agents). ## On Privacy **Will my footage be uploaded to AI companies?** No. Here's how it works: the agent (Claude, Codex, etc.) talks to Jumper via MCP (an open standard for AI agents to "talk" with software). It sends *commands* like "search for shots of Anna smiling" or "export clips to this folder." Jumper runs a **local server** on your machine (localhost). All the heavy work (visual search, transcription, face recognition) happens **on your computer**. Your footage never leaves it. What the agent receives back is **metadata** only: file paths, timecodes, transcript excerpts, search result lists. The agent orchestrates the workflow; Jumper does the actual analysis locally and returns pointers to where things are, not the footage itself. For a detailed breakdown of what data the agent receives and how model providers handle it, see [Agentic editing and data privacy](/core-concepts/agentic-editing-privacy). ## Related Step-by-step walkthrough of searching and exporting clips via an AI agent Configure and connect Claude or Codex to Jumper Give an agent layered context before it searches or builds an edit Understand the visual, speech, face, and summary layers available to agents Explore Jumper's agentic video-editing workflows # Agentic editing and data privacy Source: https://docs.getjumper.io/core-concepts/agentic-editing-privacy What the agent receives via MCP and how model providers handle it ## Overview Agents use the Jumper MCP server to interact with Jumper. This means that the agent only sees the data that is returned by the MCP server. Your footage never leaves your computer. Jumper does all analysis locally on your machine. What the agent receives is **metadata and derived data** — not your media files. ## What Jumper's MCP returns When querying the JumperMCP server, depending on the task, the agent can receive: * **Metadata** — File paths, timecodes, clip durations, similarity scores * **Downsampled thumbnails** — Low-res previews of search results so the agent can assess which matches fit your query (e.g. which "man in a red shirt" shot is best) * **Transcription excerpts** — When the task involves speech search, the agent receives the transcribed text for the relevant segments No media files are uploaded. No raw video or audio is sent to the model provider. ## The privacy boundary Data flows like this: ```mermaid actions={false} theme={null} flowchart LR subgraph On your machine direction LR media[Media] <--> jumper[Jumper] jumper <--> mcp[MCP] end agent[Agent] --queries--> mcp mcp --metadata--> agent ``` Jumper controls what goes out. The agent only sees what the MCP endpoints return. ## Local vs remote models **Local model** — If the agent runs a local model (e.g. Codex with a local LLM), the MCP responses never leave your machine. **Remote model** — If the agent uses Claude API or OpenAI, the tool output becomes part of the prompt sent to the provider. That means metadata, thumbnails, and transcript excerpts you return are processed on their servers. Same as pasting that data into ChatGPT. ## Model provider policies Each provider has its own data handling: * **Anthropic (Claude)** — Commercial customers: no training on your data unless opted in. Enterprise can enable Zero Data Retention (ZDR). Standard retention: 30 days. Note: data processed by third-party tools and MCP servers is not covered by ZDR; review each integration. * **OpenAI** — Check their [API data usage policies](https://openai.com/policies/api-data-usage-policy) for retention and training. For strict requirements, contact the provider about enterprise options. ## Related How agents operate Jumper via MCP Where your data lives when using Jumper without agents # AI Video Analysis, Understanding, and Tagging Source: https://docs.getjumper.io/core-concepts/ai-video-analysis Learn how Jumper analyzes and automatically indexes visual content, speech, people, summaries, and technical metadata without manual video tagging. Jumper combines complementary AI video-analysis layers to help editors and compatible AI agents understand footage. The analysis creates a searchable local index of visual content, speech, recurring people, summaries, and supported technical metadata without requiring an editor to label every shot by hand. Each result stays connected to the underlying media and source time range. Jumper stores the index in separate [analysis files](/core-concepts/processing#analysis-files) and leaves the original video, image, and audio files unchanged. ## Four video-analysis layers Makes actions, objects, settings, compositions, visual style, and visible emotions searchable. Creates timestamped transcripts for finding dialogue, topics, and named speakers. Groups recurring people so editors can name them and find where they appear. Creates layered descriptions of long-form footage tied to progressively narrower source ranges. ## AI video tagging and automated metadata logging In Jumper, **AI video tagging** and **automated video logging** describe the AI-generated analysis and searchable index. Jumper does not write keyword tags into source media files. The four analysis layers above make picture, speech, people, and long-form context searchable. [Metadata filters](/interface/search-tab#metadata-filters) complement that analysis by narrowing results using supported properties such as date, duration, codec, resolution, frame rate, camera, or lens. ### How can I automatically tag or index video footage? [Analyze the media in Jumper](/core-concepts/processing) and select the visual, speech, face, and Summary Analysis types the workflow needs. Editors can then search the generated index directly instead of assigning a keyword to every shot. For recurring ingest, [Watch Folders](/guides/watch-folders) can automatically analyze new media added to selected directories. The processing and Watch Folder guides cover settings such as analysis models, speech language, face collections, and exclusions. ### AI-generated indexing versus Tag Collections AI-generated indexing and Jumper's Tag Collections serve different purposes: | Feature | Who creates it | Purpose | | - | - | - | | AI video tagging and analysis | Jumper | Makes the content and metadata of analyzed footage searchable without manual shot-by-shot labels. | | [Tag Collections](/guides/tag-collections) | Editors and collaborators | Saves selected segments or whole clips for review, comments, color coding, sharing, filtering, and later reuse. | Tag Collections do not replace analysis, and automatic analysis does not create editor-curated Tag Collections. ### Scene detection When a visual query matches footage, Jumper detects the continuous time range where that query remains relevant and returns the range as a **scene** with a start time and end time. Scene detection is query-dependent: the returned range describes where the current visual search matches. Jumper does **not** automatically divide every media file into traditional editorial shots or claim that each scene boundary is a camera cut. See [Scene detection and search results](/core-concepts/visual-search#scene-detection-and-search-results) for the detailed behavior. ## Which AI can analyze or understand video? Jumper analyzes video with a combination of local visual, speech, face, and summary models rather than relying on a single general-purpose model. Editors can search the resulting information in Jumper, and compatible AI agents can navigate the same analysis through Jumper's local MCP integration. The available models and hardware support vary by platform. See [Machine Learning models](/core-concepts/machine-learning) and [Jumper compatibility](/compatibility) for current requirements. ## How editors and AI agents use the analysis Editors can directly search for visual concepts, spoken words, speakers, and people. They can also use Summary Analysis to understand unfamiliar or long-form footage before running a focused search. With [agentic video editing](/core-concepts/agentic-editing), a compatible agent can inspect the same analysis, plan searches, retrieve relevant source ranges, review timelines, and prepare clips or sequences. Jumper performs the media analysis and retrieval locally; the agent orchestrates the workflow. ## Verification and source evidence Summary Analysis provides orientation and context, not final evidence. Verify exact quotes against [timestamped transcripts](/core-concepts/speech-search), identities against named face results or source frames, and edit points against the original media. Any factual claim derived from a summary should be checked against a transcript, frame, or source-media range before publication. This keeps the fast orientation layer separate from the evidence used in an edit. ## A local editorial system, not a cloud analysis service Analysis runs locally on supported macOS and Windows computers. Jumper is an editorial application with a [local Public API](/api-reference/introduction) and MCP integration; it is not a cloud video-analysis service, and source footage does not need to be uploaded for analysis. See [Local and Offline](/core-concepts/data-sovereignty) for the privacy and data-flow details. See how local video understanding supports search and editing workflows. See how automated video logging fits into an editorial workflow. ## Related documentation Prepare footage for visual, speech, face, and Summary Analysis. Automatically analyze newly added media. Navigate layered descriptions while preserving source references. Let compatible agents work with Jumper's analysis and editing tools. # Local and Offline Source: https://docs.getjumper.io/core-concepts/data-sovereignty Everything runs on your device. Your footage never leaves your computer. ## Overview Everything Jumper does happens on your computer. All media analysis, indexing, and search operations run **locally** on your machine. Your footage never leaves your computer, and Jumper doesn't need cloud storage or external processing to work. Your media stays yours. Jumper never takes custody of your footage. ## Where Your Data Lives * All your media files stay where you put them (local drives, NAS, or your own servers). * All the analysis work (speech transcription, face detection, visual indexing) happens **on your computer** or your local network. * Jumper only creates metadata files (indexes, thumbnails, transcriptions) that are stored locally with your media. * Your actual footage never gets sent anywhere. ## Internet Connection Jumper works **completely offline**. Your media, metadata, and analysis results never get uploaded to any servers. The only times Jumper needs internet are: * Activating your license * Updating the software * Downloading machine learning models * Sending crash reports to [Sentry](https://sentry.io/) when something goes wrong (see [Crash logging](/reference/crash-logging) to disable) None of these involve your actual footage or project files. Once the models are on the machine, analysis and search run offline. If a firewall blocks the download, [copy the models folder](/guides/offline-models) from an internet-connected machine. ## You're in Control You own and control everything: * Your media files * The analysis files Jumper creates * All cache data Jumper can't access, view, or retrieve content you don't explicitly share with it. Access to your files is controlled by your computer's permissions, just like any other application. ## Team Environments When using Jumper in a shared setup: * All indexes and cache files stay on **your infrastructure** (your servers, your network). * Jumper doesn't add any new access permissions beyond what your storage and network already allow. * Your existing IT and security policies control who can access what. ## Deleting Your Data Jumper doesn't keep copies of your data. When you delete media files or cache files from your computer, they're gone from Jumper too. If you uninstall Jumper, it doesn't leave anything behind except the cache files you created, which you can delete yourself if you want. ## Agentic editing When using [agentic editing](/core-concepts/agentic-editing), the agent may run remotely. See [Agentic editing and data privacy](/core-concepts/agentic-editing-privacy) for how that affects data flow. # Face detection Source: https://docs.getjumper.io/core-concepts/face-detection Detect and identify people in your footage This feature requires a Jumper Pro license ## Overview Face detection allows Jumper to automatically identify people appearing in your footage. Once detected, you can search for specific individuals and quickly find all scenes where they appear. ## How it works Face detection works by analyzing your media files to identify and group similar faces together. In the Media tab, mark which files should be analyzed for face detection. Select which Collection to add the detected faces to. Jumper processes the media and groups similar faces together. Assign names to the detected people in the People tab. Once named, you can search for people using the @ syntax in the Search tab, like @John sitting on a bench. Select multiple people and use the AND/OR control to find shots where they appear together (AND) or where any of them appear (OR). Step-by-step guide to using face detection ## Collections When you analyze media with face detection, the identified faces are added to a **Collection**. Collections are containers that isolate people from different projects or productions, keeping your identified people organized and context-specific. **Why Collections?** Collections prevent people from different productions from mixing together. For example: * If you're working on a TV show, you can create a collection for that show's cast * When you start a new production, create a separate collection for those people **How Collections work:** * Each collection is independent. People identified in one collection don't appear in others * You can create multiple collections for different projects, shows, or any organizational structure that makes sense for your workflow * When analyzing media, you choose which collection to add the detected faces to * When new media is analyzed to an existing collection, Jumper will try to match the faces to the existing named people in the collection. If a match is found, the face is added to the existing person. If no match is found, a new unnamed person is created. You can view and manage all your collections in the [People tab](/interface/people-tab) ## Thresholds Jumper's face detection algorithm extracts faces from the media files and then groups them together based on similarity. * The algorithm will try to exclude low res or blurry faces * The algorithm may create multiple groups for the same person if the confidence is low ## Merging and regrouping Sometimes the face detection algorithm may create separate groups for the same person, or group different people together. This can happen when: * Lighting conditions vary significantly * People appear at different angles or distances * The algorithm has low confidence in its detection You can manually merge groups that represent the same person, or regroup the entire collection with different parameters to improve accuracy. When regrouping, you can choose to preserve existing names or remove them all for a fresh start. Read more about Merging and Regrouping ## Known Issues * When searching for a person, the selection in the Context Picker is ignored. This is being worked on and will be fixed in a future update. # Licensing Source: https://docs.getjumper.io/core-concepts/licensing About Jumper licenses ## Valid license key You will need either a free trial license key or a paid license key to use Jumper. With the free trial you can analyze any amount of media, but you will only be able to search 40 times. Try it out for free Available in Standard, Pro, or Enterprise The first-run setup/status window doesn't have the license key field. Open Jumper Standalone or your NLE panel, go to the [Settings tab](/interface/settings-tab#license-key), enter your license key, and click **Apply**. You can manage your licensing by logging in with your account at [getjumper.io](https://getjumper.io). ## Enterprise licenses Enterprise includes everything in Pro plus the Enterprise Admin Panel for centrally managed configurations, access policies, and company single sign-on (SSO). See the [Enterprise overview](/enterprise/overview) for what it does and how to set it up. ## One license key per device When you activate your license key, it is linked to the device you are using Jumper on. If you want to use Jumper on a different device, you have two options: * unlink the license key from the old device and activate it on the new device * purchase an additional license key ## How to unlink a device Go to the [Jumper website](https://getjumper.io) and log in to your account by clicking the **Log in** button in the top right corner. You will see a list of your licenses and the devices they are linked to. Click the red Trash can button next to the device you want to unlink. This will free up your license key so you can activate it on a new device. Release device ## Lifetime license updates Lifetime licenses include 1 year of free updates. After that year, you can keep using Jumper forever, but updates are optional. If at any time in the future you want another year of updates, you can purchase it at 50% off the regular lifetime license price. # Machine Learning Source: https://docs.getjumper.io/core-concepts/machine-learning Understanding how Jumper uses AI models to search, transcribe, recognize people, and summarize footage ## Overview Jumper uses four types of machine learning models to help you understand and search through your footage: AI systems that can "see" and understand images and video frames, then connect that understanding to text queries or other images. AI systems that can transcribe spoken words into searchable text. AI systems that can identify and group similar faces together, allowing you to search for specific people. AI systems that turn analyzed media into layered, navigable descriptions for editorial research and AI-assisted workflows. All models run entirely on your local machine, ensuring your footage never leaves your computer. ## Visual Search Models Visual search models are AI systems that can "see" and understand images and video frames, then connect that understanding to text queries or other images. This is what makes Jumper's visual search work. **How visual search models work:** These models learn to find correlations between text and visual data from their training material. When you search for something like "a person walking through a door," the model has learned to understand: * What "a person" looks like visually * What "walking" means in terms of motion and pose * What "a door" is and how it appears in different contexts * How these elements relate to each other in a scene When you perform a text search, the model identifies the best matching visual elements in your footage. Thanks to efficient algorithms, this makes it possible to find visual content across thousands of hours of video. The model doesn't just match keywords. It understands the semantic meaning of your search query and finds frames that match that meaning, even if the exact words don't appear in the footage. **Search methods:** * **Text search**: Enter a natural language query to find matching visual content * **Image search**: Use an image or frame as your search input instead of text. The model uses similar algorithms to find visually similar content across your footage **What this means for you:** * You can search using natural, conversational language * You can search using images or frames from your footage * The model understands context and relationships between objects * It works across different languages (multilingual models) * Higher resolution models can detect finer details like text on signs or small objects **Model characteristics:** * **Size**: Larger models generally offer better accuracy but require more memory and processing power * **Resolution**: Higher resolution models (384×384, 512×512) analyze frames in more detail, useful for detecting text, small objects, or fine visual details * **Speed**: Smaller models analyze faster, while larger models take more time but provide better results For a complete list of available models and their specifications, see the [List of Machine Learning Models](/reference/machine-learning-models). ## Speech Models Jumper uses different local speech-to-text models for different languages. Select the language spoken in your footage before analysis, and Jumper routes it to the most appropriate model for your platform. ### How languages are routed Languages on the same line use the same speech model: * **English** * **Swedish** (shoutout [kb-whisper](https://kb-labb.github.io/posts/2025-03-07-welcome-KB-Whisper/)) * **Japanese** * **Moroccan Arabic (Darija)** * **Arabic, Cantonese, Chinese (including Mandarin), Filipino/Tagalog, Hindi, Korean, Malay, Persian, Russian, Thai, and Vietnamese** * **All other supported languages** The specialized Swedish, Japanese, and Moroccan Arabic models achieve state-of-the-art word error rates (WER) for their target languages. Lower WER means fewer transcription errors. The shared multilingual base model is also highly competitive across its supported languages. We plan to add more specialized language models in the future, improving transcription language by language as strong new models become available. ### How speech analysis works The selected speech model listens to your media's audio track and converts speech into text during analysis. Once the media is analyzed, you can search for any word or phrase that was spoken. **Key features:** * Supports more than 100 languages and language variants * Selects a model based on the language you choose * Handles different accents, background noise, and audio quality * Transcribes dialogue with timestamps * Works entirely offline with no cloud processing required Speech analysis can also transcribe one or more selected audio channels and detect speakers. For details, see [Speech search](/core-concepts/speech-search). The exact model available can vary by platform and hardware. For the complete language list, see [Supported Languages](/reference/supported-languages). ## Face Detection Models Face detection requires a Jumper Pro license Face detection uses specialized AI models to identify and recognize people in your footage. These models analyze faces frame by frame, extract facial features, and group similar faces together. **How face detection models work:** The face detection algorithm processes each frame of your media to: * Detect faces in the frame * Group similar faces together, even when lighting, angles, or expressions change **What this means for you:** * Automatically identify all appearances of a person across your entire footage library * Search for specific people using the `@` syntax (e.g., `@John sitting on a bench`) * Organize people into Collections to keep different productions separate * Find every scene where someone appears, even if they're in the background For more information about using face detection, see [Face detection](/core-concepts/face-detection). ## Summary Analysis Models [Summary Analysis](/core-concepts/summary-analysis) creates a concise whole-clip overview followed by progressively more detailed sections connected to source time ranges. This gives editors and AI agents context before they perform targeted searches. The model is downloaded and runs locally. Choose from **Small**, **Medium**, **Large**, or **Extra large** in the Summary Analysis configuration. Visual analysis is required; optional speech and face analysis can make the result more useful. ## Choosing the Right Visual Model Depending on your specific workflow, usecase and hardware setup, you might want to choose a specific model other than the default. Some suggestions are listed below, or feel free to explore from all the available models. Quick analysis with good accuracy, 256x256 resolution. Great for most workflows. Larger model with higher accuracy, 256x256 resolution. Top-tier accuracy with 384×384 resolution. Benefits from more detailed and verbose searches, great multilingual support. Highest accuracy with 512x512 resolution among the V1/V2 presets. Benefits from more detailed and verbose searches, great multilingual support. State-of-the-art visual search quality using a different model architecture than the presets above. Available on Apple silicon Macs and Windows. Requires a separate download, more compute, and produces larger analysis files. Choose this when search quality matters more than analysis speed. For a complete list of all available models with detailed specifications, see the [List of Machine Learning Models](/reference/machine-learning-models). # Analyzing media Source: https://docs.getjumper.io/core-concepts/processing Analyze footage locally to create separate searchable data for AI video tagging, automated logging, visual search, speech, faces, and summaries. ## Overview Before you start searching, Jumper analyzes the media and creates a separate local index. This process is also described as [AI video tagging and automated video logging](/core-concepts/ai-video-analysis#ai-video-tagging-and-automated-metadata-logging): Jumper makes footage searchable without requiring an editor to label every shot manually. The complete [AI video-analysis system](/core-concepts/ai-video-analysis) combines visual, speech, face, and Summary Analysis. Choose only the layers that the workflow needs. You can select to process visuals and/or speech for every media file in the Media table When you have selected media to analyze, click the button at the bottom. Jumper will start to analyze the media. This will take some time depending on the runtime, resolution and chosen model. Read more about different models [here](/core-concepts/machine-learning) After a media file has been processed, the checkbox(es) will turn green. This means that the file is now searchable with Jumper. ## Add editorial context with Summary Analysis After visual analysis is complete, [Summary Analysis](/core-concepts/summary-analysis) can create a layered description of a file. Start with a concise overview, then navigate into detailed sections and source time ranges before running targeted visual, transcript, or people searches. To run one, see [Create a Summary](/guides/create-summary-analysis). This is especially useful when an editor or AI agent needs to understand unfamiliar footage before deciding what to search for. ## Analysis speed The analysis speed varies depending on your computer specifications and the chosen model. As a reference, on a Mac M1 Pro MacBook Pro, the fastest visual search model typically achieves 15 to 20 times real-time analysis, meaning one hour of footage takes about three to four minutes to analyze. ## Analysis files When you analyze media, Jumper creates an analysis file in the specified `Analysis folder`. This file is required for Jumper to be able to search in that file. **Analysis does not modify the source media or write AI-generated keyword tags into it.** Jumper stores its searchable data separately and leaves the original video, image, or audio file unchanged. Once analyzed, you may rename or move the original media files as you wish. The analysis files are linked by the content of the media files, not their filepath or filename. If you delete any of these files, you will need to re-analyze the corresponding media files. ### Size of analysis files The size of the analysis files varies depending on the resolution and frame rate of the media files. As a rough estimate, the analysis data is about 0.1% of the size of the original media file. ### Analysis files and Machine Learning models Analysis files are tied to the specific machine learning model that was used to create them. If you download and load a new model in the [Settings tab](/interface/settings-tab), you will need to re-analyze your media files with the new model before you can search in them with that model. Switching to a new model does *not* delete or overwrite your previous analysis files; instead, new analysis files are created for the new model. If you later switch back to a previous model, any analysis files created for that model will still be available, so you will not need to re-analyze your media for that model again. ## Supported file formats Jumper can analyze various video, image, and audio file formats. See the complete list of [supported file formats](/reference/supported-file-formats). # Speech search Source: https://docs.getjumper.io/core-concepts/speech-search Find spoken words, label speakers, and open search results in the full transcript Speech search result with a detected Speaker 2 label and the Show in script action ## Overview Speech search finds words and phrases in transcribed dialogue. Results show the matching line, timecode, source file, and detected speaker. When speaker detection is enabled, Jumper labels voices as **Speaker 1**, **Speaker 2**, and so on. Name these speakers to filter later searches. ## How transcription works Jumper's [speech models](/core-concepts/machine-learning#speech-models) convert dialogue into timestamped text during speech analysis. The analysis: * Converts speech to text with timestamps * Stores the transcript for searching * Runs entirely on your local machine Transcription accuracy varies with accents, background noise, and audio quality. ## Audio channels You can transcribe one or more selected audio channels. Set which channels to transcribe per file in the [Media tab](/interface/media-tab). This is useful when dialogue is split across channels, such as a separate lavalier per speaker. When several channels contain the same dialogue, Jumper merges the transcripts and removes the duplicate speech, so a phrase picked up by two mics doesn't show up twice in your results. ## Speaker detection Speaker detection is on by default. Jumper separates voices and assigns labels such as **Speaker 1** and **Speaker 2**. To name a detected speaker: 1. Run a Speech search. 2. Click the speaker label on a result. 3. Enter the speaker's name and click **Save**. Rename Speaker dialog with a name entered and the transcript-only notice Jumper updates that speaker label throughout the transcript. The name is saved for that transcript only. It does not carry across other media files or transcripts. Named speakers appear in **Filters** for Speech search. Select a name to limit results to that speaker. If you know the cast size, set the expected speaker count before analysis to **Auto**, **1**, **2**, **3**, **4**, or **5+**. A close count can improve detection. Overlapping speech and very short lines can still be mislabeled, so review the results and rename speakers where needed. ## How search works Jumper searches the transcripts of your analyzed media and ranks exact and fuzzy matches. * **Exact matches** contain the word or phrase you entered. * **Fuzzy matches** include close spellings and similar-sounding words. Each result includes a timecode and source file. ### Open a result in the full transcript Click **Show in script** on a result. Jumper switches to the dedicated [Script tab](/interface/script-tab), opens the full transcript, and takes you to the matching line. From there, review the surrounding dialogue, remove unwanted segments, jump to source timecodes, add selects to the timeline, or export the transcript. ## Language support Jumper supports more than 100 languages and language variants. Select the spoken language before analysis so Jumper can route the audio to the appropriate [speech model](/core-concepts/machine-learning#speech-models). For a complete list of supported languages, see [Supported Languages](/reference/supported-languages). ## Transcription files Speech analysis generates two plain text transcript files for each media file. Right-click the file in the Media tab to open its transcript or locate its speech analysis files. Media tab context menu with transcript, analysis, and file actions Use the context menu actions to: * **View transcript** switches to the [Script tab](/interface/script-tab) and opens the file's full transcript. * **Reveal Speech Analysis** opens the speech analysis folder in Finder. The same menu includes shortcuts for summaries, source media, analysis folders, and cleanup. The speech analysis folder contains two plain text files: 1. `transcription-full-text.txt` contains the complete transcript. 2. `transcription-segments.txt` splits the transcript into timestamped segments. Speech analysis folder with the generated transcript files Use the text file to: * Review or edit the transcriptions outside of Jumper * Share transcriptions with others * Use the transcriptions in other applications * Verify what was transcribed ## Frequently Asked Questions Yes. Jumper detects speakers, lets you name them per transcript, and lets you filter Speech searches by named speaker. See [Speaker detection](/core-concepts/speech-search#speaker-detection). Yes. Select one or more channels. When the same dialogue appears on multiple channels, Jumper merges the transcripts and removes duplicate speech. See [Audio channels](/core-concepts/speech-search#audio-channels). # Summary Analysis Source: https://docs.getjumper.io/core-concepts/summary-analysis Create layered, navigable descriptions of long-form footage for editorial research, source-range discovery, and agentic video-editing workflows. Summary Analysis gives you and your AI agent a fast way to understand footage before searching for individual shots, quotes, or people. It creates a layered textual description of each media file, beginning with a concise overview of the entire clip. It is the long-form orientation layer in Jumper's broader [AI video-analysis system](/core-concepts/ai-video-analysis), alongside visual, speech, and face analysis. From that overview, you can progressively open more focused sections. Each level adds detail and points back to source time ranges, so you can move from “What is this clip about?” to the moments that deserve closer review. To run an analysis, see [Create a Summary](/guides/create-summary-analysis). Summary Analysis showing a clip overview, progressively narrower time ranges, detailed text, and a source preview ## Why use Summary Analysis Visual, speech, and people searches are most effective when you already know where to look. A Summary Analysis gives an editor or agent that initial map of the footage. For example, an agent can read the overview of a long interview, open only the sections about a promising topic, and then limit its transcript search to those source ranges. On a documentary archive, it can compare overviews across many files before spending time on detailed searches. A summary is navigation and reasoning context, not final source evidence. Verify exact quotations in the underlying transcript, identities with frames or People analysis, and edit points against the source media before using them in an edit or factual claim. ## Purpose, goals, and priorities Purpose and goal work together, but they do different jobs. A built-in purpose adds a familiar editorial lens (documentary research, trailer creation, archive discovery, and similar). A **Specific goal** makes that lens particular to this footage and deliverable. **Use only my instructions** skips the built-in lens and relies on your goal and **Pay extra attention to** priorities alone. For the exact settings and steps, see [Create a Summary](/guides/create-summary-analysis#purpose-and-specific-goal). ## Reuse the same footage for different questions The first Summary Analysis of a file takes longer because Jumper creates the initial factual observations it needs to describe the media. Later analyses of the same file can reuse those observations and concentrate on a different editing goal. You can create multiple Summary Analyses for one file. A documentary team might create one analysis for story research and another for trailer moments. Give each analysis a meaningful name so collaborators and AI agents can identify the right one without opening every result. **Summary collections** organize related analyses across multiple files—for example, all interviews from one production day or all reels from one archive box. Collections keep every source file distinguishable, allowing you and an agent to compare related material without losing track of where each observation came from. ## Practical uses Understand interviews, observational scenes, characters, relationships, and themes before deciding on a story structure. Surface promising hooks, confrontations, reversals, striking images, and memorable reactions for closer review. Locate topic changes, strong statements, personal stories, and sections that may become selects. Survey large collections, compare files, and focus detailed searches on the most relevant source ranges. Find key moments, crowd energy, turning points, reactions, and sequences worth considering for a highlight reel. Follow characters, relationships, themes, locations, props, or continuity details across related footage. ## How AI agents use summaries When Summary Analysis is available, an AI agent such as Claude or ChatGPT can use it quietly in the background to orient its work. It inventories available collections, reads concise whole-clip overviews first, and drills only into branches that look promising. Later visual, transcript, or people searches can then be limited to those source time ranges. This progressive approach gives the agent useful context without treating every summary sentence as proof. It still verifies selected material against the transcript, frames, People analysis, or source media before creating an edit or making a factual claim. Run Summary Analysis on a file or batch and explore the result. Prepare footage for visual, speech, face, and summary workflows. Learn how Claude, ChatGPT, and other AI agents work with Jumper. Compare Jumper's visual, speech, face, and summary layers. # Visual search Source: https://docs.getjumper.io/core-concepts/visual-search Search analyzed visual content with text or reference images and return continuous query-matching scenes with precise source start and end times. Visual search results for "golf" showing thumbnails across 79 files ## Overview Visual search is Jumper's core capability for finding specific visual content in your footage. Unlike traditional keyword-based search, visual search uses advanced machine learning models (specifically [Visual Search Models](/core-concepts/machine-learning)) to understand the semantic meaning of what you're looking for and match it to frames in your media. When you perform a visual search, Jumper analyzes your query (whether text or an image) and compares it against the visual understanding it has already extracted from your analyzed footage. This allows you to find content based on what things *look like* or *what's happening* in the scene, not just metadata or filenames. Visual search does not rely on manual keyword tags or technical metadata to understand what is pictured. Jumper analyzes the actual visual content of your footage, so you can search for visible concepts without labeling every shot first. You can separately use [metadata filters](/interface/search-tab#metadata-filters) to narrow which source files are searched. This visual layer is part of Jumper's broader [AI video analysis and searchable video index](/core-concepts/ai-video-analysis). ## Text-based search Text-based visual search lets you describe what you're looking for using natural language. Jumper's visual search models understand the semantic meaning of your query and find frames that match that meaning, even when the exact words don't appear in the footage. ### How it works When you search for something like "a person walking through a door," the model understands: * What "a person" looks like visually * What "walking" means in terms of motion and pose * What "a door" is and how it appears in different contexts * How these elements relate to each other in a scene The model doesn't just match keywords. It understands concepts, relationships, and context. This means you can search using conversational, descriptive language and still get accurate results. ### Language support Text-based search works best in English, but if you've analyzed your footage with a [multilingual model](/core-concepts/machine-learning), Jumper can understand search queries in approximately 80 languages. The model recognizes the same visual concepts regardless of the language you use to describe them. For example, searching for `white cat`, `gato blanco`, or `白い猫` will likely return the same results because the model understands these are all descriptions of the same visual concept. SCR-20250511-jesb.avif ## Image-based search Image-based search works differently from text search. Instead of describing what you're looking for with words, you provide an image, and Jumper finds scenes in your footage that are visually similar to that image. ### How it works When you search by image, Jumper's models analyze the visual characteristics of your search image (colors, composition, objects, people, settings, and overall visual style) and find frames in your footage that share similar visual properties. This works well for finding: * More footage of the same person (even from different angles or lighting) * Similar locations or settings * Shots with matching visual style or composition * Objects or scenes that look similar but might be described differently SCR-20250511-jgwp.jpeg ### Image sources Jumper provides several ways to use images for search, each designed for different workflow scenarios: | Image Source | Description | | - | - | | **Match Source/Event Monitor** | Uses the frame currently visible in your editing software's Source Monitor (or Event Viewer in Final Cut Pro). Useful for finding similar shots elsewhere in your footage while reviewing a clip. | | **Match Timeline** | Uses the frame currently visible in your Timeline Monitor (or Timeline Viewer in Final Cut Pro). Helps you find alternative takes or similar shots to what's already in your timeline. | | **Match Pasteboard** | Uses any image you've copied to your system's clipboard. Allows searching with screenshots, reference photos, images from the web, or frames captured from other applications. | | **Find Similar** | Uses a thumbnail from your existing search results. Lets you refine your search, finding more scenes that match a specific result. This enables an iterative workflow where each result can become the starting point for further search. | ## Scene detection and search results When Jumper performs a visual search, it returns results as **scenes**; segments of media files with a defined start time and end time. Each scene represents a continuous portion of a file where the search query matches the visual content. scenes-in-files.avif Jumper detects where the visual content begins and stops matching the current query, then returns that continuous range instead of an isolated frame. These query-dependent scenes do not automatically divide every file into traditional editorial shots, and their boundaries do not necessarily represent camera cuts. See [AI video analysis: Scene detection](/core-concepts/ai-video-analysis#scene-detection) for the distinction between query-matching scenes and editorial shot detection. ## Related Tips and tricks for getting the best search results in Jumper Learn about the Search tab in Jumper # Developers Source: https://docs.getjumper.io/developers Build custom tools on top of Jumper's local analysis and search using the Public API or AI agents. Jumper runs locally and handles the heavy work: analyzing footage, visual and speech search, face recognition, thumbnails, and exports. You build the workflow layer: a review UI, a batch tool, a facility pipeline, or an NLE plugin tailored to how you actually edit. Everything stays on your machine. Your app talks to the Jumper backend over a local API at `http://localhost:6699/api/v1`. ## What Jumper handles vs what you build **Jumper handles:** * Visual, transcript, and image search across analyzed media * Speech transcription and face clustering * Thumbnails, metadata, and clip exports * Watch folders and analysis data management **You build:** * The interface or automation that fits your workflow * How results are reviewed, saved, renamed, or handed off * Integrations with other tools you already use Your app does not need to solve video AI, indexing, or media analysis. It calls Jumper and focuses on the part only you know: your bins, naming conventions, review rituals, and handoffs. ## How it fits together ```mermaid actions={false} theme={null} flowchart LR YourApp["Your app, script,\nor AI agent"] API["Jumper API\nlocalhost:6699"] Core["Analysis, search,\nfaces, export"] Media["Your footage +\nanalysis folder"] YourApp --> API --> Core --> Media ``` ## Two ways to extend Jumper Build a persistent tool with its own UI or automation. Search, review, and export, wired to your workflow. Describe tasks in plain language. An AI agent orchestrates Jumper for you: search, export, timeline round-trips. Use the **Public API** when you want a standalone app, script, or integration that runs the same way every time. Use **MCP** when you want a conversational agent to figure out the steps on the fly. ## Who this is for * **Editors** with a niche workflow that the main Jumper UI does not cover * **Post supervisors and facility teams** automating recurring steps across a shop * **Developers** building tools on top of local media analysis You do not need to be a programmer to get started with the Public API. If you can describe what you want clearly, a coding agent (Cursor, Codex, Claude Code, or similar) can build a first version from the [API reference](/api-reference/introduction) and [OpenAPI spec](/api-reference/openapi-v1.yaml). For a walkthrough of building and iterating on a custom app, see the Jumper blog: * [Vibe Coding for Video Editors 101](https://getjumper.io/blog/vibe_coding_for_video_editors_101) * [Vibe-Coding Your Own Video Editing Tools](https://getjumper.io/blog/vibe_coding_your_own_video_editing_tools) ## What people build Common starting points: * A custom search and review UI (timeline, deck, keyboard-driven selects) * A batch export or rename tool for dailies or stringouts * A facility script that searches analyzed media and writes results to shared storage * A small local web app that combines Jumper results with another tool you already use Start small. Prove the connection works, then add features one at a time. ## Before you begin This requires a **Jumper Pro** license. Keep Jumper running while you test. The API is local. Have these ready: * Your **Jumper Pro license key**: find it in the [Settings tab](/interface/settings-tab#license-key) * The path to your **analysis folder**: configured in [Settings](/interface/settings-tab#analysis-folder) * **Analyzed media**: search only works on footage Jumper has already processed. See [Processing](/core-concepts/processing). ## Get started Build a small search app with a coding agent. Step-by-step. Authentication, workflow, endpoint groups, and examples. Raw YAML and JSON for generated clients and agent tooling. Search and export clips via an AI agent instead of building your own app. ## Share what you build Built something useful, chaotic, or both? We would like to see it. Send us an email at [hello@getjumper.io](mailto:hello@getjumper.io) Join our Discord server # Public API Source: https://docs.getjumper.io/developers/api Build local media-analysis and video-search integrations with the Jumper Public API, generated endpoint reference, and canonical OpenAPI files. The [Jumper Public API reference](/api-reference/introduction) documents a local REST API for media analysis, visual and transcript search, face clustering, summaries, watch folders, thumbnails, and exports. The generated endpoint pages and canonical OpenAPI files live in the API Reference section. This page is a compatibility entry point. The canonical API docs and spec files are: * API overview: `/api-reference/introduction` * Raw OpenAPI YAML: `/api-reference/openapi-v1.yaml` * Raw OpenAPI JSON: `/api-reference/openapi.json` * Markdown reference: `/api-reference/public-api-v1.md` Use the raw OpenAPI YAML or JSON as the schema source of truth. Start with authentication, workflow, examples, and endpoint groups. Download the raw OpenAPI YAML, JSON mirror, and full Markdown reference. # Your first Jumper app Source: https://docs.getjumper.io/developers/your-first-app Build a small local app that connects to the Jumper API and returns search results. This guide walks you through building a minimal app on top of the Jumper Public API: a search box, a submit action, and a results list with thumbnails. That is enough to prove the setup works. **Before you begin:** Jumper is running with [media analyzed](/core-concepts/processing), you have a [Jumper Pro license](/interface/settings-tab#license-key), and you know the path to your [analysis folder](/interface/settings-tab#analysis-folder). You do not need to write the code yourself. Paste the starter prompt below into a coding agent (Cursor, Codex, Claude Code, or similar) and follow its instructions. ## Starter prompt Copy this into your coding agent: ``` Build a very small local app that connects to the Jumper API. Goal: 1) Show a search input box 2) Send the query to Jumper 3) Render results as a simple list with thumbnails and clip info When done, tell me exactly how to test it. Assume that I have Jumper Pro running and my footage is already analyzed. Use this API reference: https://docs.getjumper.io/api-reference ``` ### Optional: specify a tech stack If you have a preference, say so in the prompt. Many agents default to JavaScript. ``` Use JavaScript with React, shadcn components, and Tailwind for styling. ``` Other stacks work too, including a CLI in Python, a desktop app, or a plain HTML page. The Jumper API does not care what language or framework you use. ### What the agent will ask for When testing, the agent or app will usually need: * Your **Jumper Pro license key** * The path to your **analysis folder** (the `cache_dir` in API requests) Point the agent at the [OpenAPI spec](/api-reference/openapi-v1.yaml) if it needs endpoint schemas or request fields. ## Test it The API is local. Your app talks to Jumper on your machine at `http://localhost:6699/api/v1`. Follow the instructions the agent gives you. If you are unsure, ask it: "How do I test the app?" or "Can you start the app for me?" Enter a query you know should return results from your analyzed footage. Confirm you get thumbnails and clip info back. Check that results match media you have analyzed in Jumper. Try a second query to confirm the connection is stable. ## If something breaks Paste the error message back to the agent and ask it to fix the issue. That is usually faster than debugging it yourself. * Confirm Jumper is running * Confirm the footage has been [analyzed](/core-concepts/processing) * Check the analysis folder path matches the one in [Settings](/interface/settings-tab#analysis-folder) * Confirm the `media_paths` in the request point at analyzed files * Confirm Jumper is running * Confirm the base URL is `http://localhost:6699/api/v1` * Try `GET /health` with curl. See [API reference](/api-reference/introduction#example-requests) * Confirm you have a Jumper Pro license * Check the license key is correct * Send the key in the `X-License-Key` header or in the request body as `license_key` ## What's next Once search works, add features one at a time instead of trying to build everything at once. Common next steps: * Switch from a list to a card or deck view for review * Add keyboard shortcuts for faster selects * Save favorites and batch-export them as clips * Drag a result to Finder or Explorer to export a trimmed clip * Combine Jumper results with another API or tool you already use For inspiration on iterating from a basic search UI to more elaborate review tools, see [Vibe-Coding Your Own Video Editing Tools](https://getjumper.io/blog/vibe_coding_your_own_video_editing_tools) on the Jumper blog. ## Related What Jumper handles, who this is for, and how the pieces fit together Authentication, workflow, endpoint groups, and curl examples Use an AI agent to operate Jumper directly instead of building your own app # Create and assign access policies Source: https://docs.getjumper.io/enterprise/access-policies Open the Admin Panel, create a policy that limits tabs and analysis folders, and assign it to licenses. A policy controls which Jumper tabs and analysis folders a license can use. A policy can represent a role, a production, or a combination of the two. Before you begin: you have a Jumper Enterprise license. For background on policies, see the [Enterprise overview](/enterprise/overview). ## Open the Admin Panel Select **Admin controls…** from Jumper's menu. The screenshot below shows the macOS menu bar menu. Jumper menu bar menu with Admin controls highlighted Sign in with the account that manages your organization's Enterprise licenses. Authentication opens in your system browser and returns to the Admin Panel. The sign-in screen offers Google, Microsoft, Apple, email, and **Company SSO** when configured. Enterprise Admin sign-in screen with social sign-in, work email, and Company SSO options ## Create a policy For example, create a policy for editors who should search Show A and Show B without changing their analysis or face collections. Open **Policies** and select **New**. Give the policy a descriptive **Name**. Under **Accessible tabs**, enable the tabs those licenses should be able to open. Under **Analysis folders**, choose **Specific folders** and use **Enter a path** to add the allowed analysis locations, or choose **Any folder** for unrestricted folder access. Select **Create policy**. To provide search access without analysis, face collection management, or model and settings changes, enable **Search** and disable **Media**, **People**, and **Settings**. You can also control access to **Summaries**, **Tags**, and **Help**. The example below enables Search, Tags, and Help. Policy editor allowing Search, Tags, and Help, with analysis folders restricted to Show A and Show B ## Limit access by production Add only the analysis folders that the policy's members should use. In the screenshot above, both **Show A** and **Show B** are allowed, while Show C is excluded. To keep the two shows separate, create one policy for Show A and another for Show B, each with only its own analysis folder. Allowed paths include their subfolders. Add each production's analysis folder rather than a parent folder containing several productions. Use paths as they appear on the editors' machines. For a team using both macOS and Windows, add the corresponding paths for both platforms. A macOS path alone will not match a Windows machine. The policy editor prompts you to add the missing platform's path. Keep your shared storage permissions aligned with the same production access rules. See [project-specific analysis folders](/guides/shared-analysis#confidential-footage-and-project-specific-analysis-folders) for the storage setup. ## Assign policies to licenses Open **Licenses** to see your organization's seats and their assigned policies. Use the policy dropdown beneath a license to change its memberships. You can also select multiple licenses and apply a policy to them together. Licenses page showing two selected seats assigned to Only Search and Tags and one seat with Full Access A license can belong to more than one policy, and the access granted by those policies is combined. When restricting a license, remove **Full Access** and any other policy that grants access beyond what that editor needs. A license with no assigned policy has **No Access**. Assign a policy before handing the license to an editor. Sending a configuration alone does not grant access. ## Next [Send a configuration](/enterprise/send-configuration) to the licenses you assigned. # Configure company SSO Source: https://docs.getjumper.io/enterprise/company-sso Connect your organization's OpenID Connect identity provider to the Enterprise Admin Panel. Connect your organization's identity provider through **OpenID Connect (OIDC)** so users can sign in with company credentials. The Admin Panel supports one OIDC connection for the organization. Before you begin: * You have the **Issuer URL**, **Client ID**, and **Client secret** from your identity provider administrator. * The [Admin Panel is open](/enterprise/access-policies#open-the-admin-panel). Open **Company SSO** in the Admin Panel. Enter the **Issuer URL**, **Client ID**, and **Client secret**. Click **Save candidate** to save the proposed connection. Click **Test login** and complete the sign-in in your system browser. Return to the Admin Panel and confirm that the status is **Enabled**. Company SSO settings with OIDC connection fields, Save candidate, and Test login The connection becomes active only after a successful browser test. When replacing an existing connection, the current connection remains active until the replacement passes its test. Once configured, users can enter their work email on the sign-in screen and select **Company SSO**. For help setting up Enterprise licenses or your organization's SSO connection, contact [Jumper support](mailto:hello@getjumper.io). # Enterprise overview Source: https://docs.getjumper.io/enterprise/overview How Jumper Enterprise simplifies editor onboarding, restricts access to production analysis, and controls available features. The **Enterprise Admin Panel** lets your team prepare Jumper once and apply that setup to every editor's license. Editors open Jumper to prepared media, the right models, and named people and speakers. Use it to onboard editors without per-machine setup, limit each license to specific productions, and choose which tabs each role can use. The Admin Panel is available with **Jumper Enterprise**, which includes everything in Pro plus centrally managed license policies, configurations, and company single sign-on (SSO). ## How it fits together The Admin Panel has four sections: * **Licenses:** assign policies to individual licenses or several licenses at once. * **Policies:** control which Jumper tabs and analysis folders those licenses can use. * **Configuration:** send a prepared Jumper setup to selected licenses. * **Company SSO:** connect your organization's identity provider for company sign-in. Policies define what an editor can access. Configurations provide the settings and saved state they start with. They don't include media or analysis files, which stay in your storage. Use both to prepare a working setup with the appropriate access for each role or production. For example, editors working on **Show A** and **Show B** can be limited to those shows' analysis folders and given access to Search. The team responsible for analysis and naming people keeps access to Media and People. ## Simplify editor onboarding An admin or assistant editor prepares the media, models, analysis, people and speaker names, and UI settings once, then sends the configuration to the editors' licenses. Editors activate their license and Jumper applies the setup automatically, including downloading the configured models. Once setup finishes, editors can search the prepared footage. Give them access to Search and [Tag Collections](/guides/tag-collections) so they can find clips, save selects, and use those collections to narrow later searches. ## Restrict access to sensitive productions Editors in the same facility may work on different shows with different access requirements. Analysis folders can contain thumbnails, transcripts, and other information from the footage, so access to those folders matters even when the original media is restricted. Keep each production's analysis in a separate folder and assign policies that allow only the folders each license needs. An editor working on Show A can be limited to Show A's analysis, while another editor has access to Show B. Set matching permissions on your shared storage as well. See [confidential footage and project-specific analysis folders](/guides/shared-analysis#confidential-footage-and-project-specific-analysis-folders). ## Choose the features each role can use Keep analysis and setup controls with the team responsible for them. For example, enable **Search**, **Tags**, and **Help** for editors while disabling **Media**, **People**, and **Settings**. This keeps the interface focused on finding footage and prevents those licenses from starting analysis, regrouping face collections, or changing models through those controls. Assistant editors can retain the tabs they need to analyze new footage, manage face collections, and maintain the setup. Policies control access by tab. Search still allows editors to rename transcript speakers, and Tags lets them save and update Tag Collections. ## What the editor sees On a new machine, the editor opens Jumper, enters their assigned Enterprise license key, and clicks **Apply**. Jumper then runs the organization setup automatically: 1. Load the license's organization policy. 2. Download the settings bundle and import the managed settings. 3. Download the configured models and activate the visual model. 4. Load an allowed analysis folder. Automatic organization setup downloading configured visual and speech models The first setup can take time while models download. When **Jumper is ready** appears, the editor clicks **OK** and starts searching the prepared media. The assigned policy determines which tabs the editor can use. When several analysis folders are permitted, the editor can switch between them with the **Organization Analysis folder** selector. In the example below, only the Show A and Show B folders are available. Search view with the Organization Analysis folder selector listing only Show A and Show B **In progress:** Remote Viewing and a floating license server. These features are not yet available. The existing [custom license server](/guides/custom-license-server) lets clients validate their individual license keys through a local server. It does not provide a pool of floating seats. ## Set it up Configure Jumper on the admin's machine. Control tabs and analysis folders per license. Distribute the prepared setup to licenses. Connect your identity provider. # Prepare the editor setup Source: https://docs.getjumper.io/enterprise/prepare-editor-setup Configure Jumper on the admin's machine with media, models, analysis, names, and settings before sending it to editors. Configure Jumper on the admin's machine as you want your editors to use it. You send this setup to editors in [Send a configuration](/enterprise/send-configuration). Before you begin: you have a Jumper Enterprise license. For background, see the [Enterprise overview](/enterprise/overview). Set the [analysis folder](/interface/settings-tab#analysis-folder) to the location containing the production's analysis data. For a team, use a [shared analysis folder](/guides/shared-analysis). Download the required models and load the visual model you want editors to use. Use the same visual model that was used to analyze the footage. Add the desired media to Jumper and [analyze it](/core-concepts/processing), or load the existing analysis. Give names to people in [face analysis](/guides/face-detection) and to detected speakers in [transcripts](/core-concepts/speech-search). Choose the [UI settings](/interface/settings-tab), such as the number of search results and how result thumbnails appear. Try a search to confirm that the prepared media and analysis work together. Each editor's machine needs access to the media files and analysis data. Make sure shared drives are mounted and the configured paths are available before the editor starts. When using a Jumper plugin, make the media available in the editor's NLE for playback and timeline work. ## Next [Create access policies](/enterprise/access-policies), then [send the configuration](/enterprise/send-configuration). # Send a configuration Source: https://docs.getjumper.io/enterprise/send-configuration Send a prepared Jumper setup to selected Enterprise licenses from the Admin Panel. Send a prepared Jumper setup to the licenses that should start with it. Each editor receives the configuration when they activate their license. Before you begin: * You have [prepared the editor setup](/enterprise/prepare-editor-setup), or you have an [exported settings ZIP](/interface/settings-tab#export-and-import-settings). * The licenses have [policies assigned](/enterprise/access-policies#assign-policies-to-licenses). A configuration alone does not grant access. * The [Admin Panel is open](/enterprise/access-policies#open-the-admin-panel). Open **Configuration**. Select **This machine** to capture the Jumper setup you prepared, or choose **ZIP file** and select a previously [exported settings bundle](/interface/settings-tab#export-and-import-settings). Click **Continue**. Configuration source step with This machine and ZIP file options Select policies to send the configuration to their current members. Under **Individual licenses**, you can add recipients beyond those policies. Check the total number of licenses, then click **Continue**. In this example, both licenses in the **Only Search and Tags** policy receive the same setup. Configuration recipients step with a two-license policy selected Confirm the source and recipients. Use **Show licenses** to inspect the complete recipient list, then click **Send**. A license selected through both a policy and the individual list is included only once. Configuration review showing the source machine and two recipient licenses To distribute a revised setup, prepare the changes and send the configuration again to the intended recipients. For what editors see when they activate, see the [Enterprise overview](/enterprise/overview#what-the-editor-sees). # Frequently Asked Questions Source: https://docs.getjumper.io/faq Answers about Jumper installation, licensing, privacy, offline AI footage search, supported editing software, media analysis, and performance. Can't find the answer to your question here? Use the Search bar above or join our [Discord](https://discord.getjumper.io) server to ask your question to the community and get in contact with other users. ## General Fast. We've tested on a few different machines (MBP M1, Windows i5 laptop, 2019 Ryzen desktop) and all were able to search through roughly 100 hours of footage in about 0.2 seconds. We are also actively and constantly trying to improve performance. This depends mainly on three factors: * Your machine * The resolution of the footage * The [model you are using](/reference/machine-learning-models) We've found that a MacBook M1 Pro can visually analyze around 15 minutes of footage in 1 minute but Windows users with Nvidia GPUs can analyze significantly faster. An Nvidia GPU provides the fastest analysis, followed by Apple Silicon (due to GPU acceleration). Running on the CPU is significantly slower. Jumper should not inherently affect the boot time of your NLE. If you experience slow boot times, it's likely due to the NLE having a massive master project open, causing slow indexing. You can select one or more audio channels to transcribe. When the same dialogue appears on multiple channels, Jumper merges the transcripts and removes the duplicate speech. See [Audio channels](/core-concepts/speech-search#audio-channels) for details. ## Licensing & Account management The first-run setup/status window doesn't have the license key field. Open Jumper Standalone or your NLE panel, go to the [Settings tab](/interface/settings-tab#license-key), enter your license key, and click **Apply**. A license is for one active computer. You can activate it on as many computers as you want but only one computer can be active at a time. Yes, any workstation that needs to read or access shared analysis data created on a different machine must have a Pro tier license. Use the email associated with your license key and go to [getjumper.io](https://getjumper.io/) and click the **Log in** button, and enter your email there. A login link should be emailed to you shortly. Click it and you will be taken to the License Management portal at the website. There you will see a red trashcan under the "Device fingerprint" for your license. Click the red trash can to sign out the currently active computer. Now you can apply your license key on another computer. sign-out-device.avif **For paid licenses:** Yes. Licenses require re-validation only once a week via an internet connection. After successful validation, the license is valid for one week of fully offline use. **For trial licenses:** An internet connection is always required. Click **Log in** at the top of the main website [here](https://getjumper.io/account) to cancel your subscription. Click **Log in** at the top of the main website [here](https://getjumper.io/account) to change your payment method. Read the [Jumper Refund Policy](/legal/refund). ## Privacy & Data No, we don't upload the data analyzed from your footage, or any part of your footage. The analysis is done **locally** and **stays on your computer**. No. Jumper needs an internet connection for **license verification**, software updates, and **downloading models**. Once the license is verified and the models are on the machine, analysis and search run offline. If a firewall blocks model downloads, [copy the models folder](/guides/offline-models) from an internet-connected machine. Nothing related to you or your footage ever leaves your computer, apart from licensing information and crash reports. Read the [Jumper Privacy Policy](/legal/privacy). Jumper uses [Keygen](https://keygen.sh) for managing licenses, and therefore you should whitelist the `api.keygen.sh` domain in your firewall settings. That allowlist covers license checks only. If the firewall also blocks model downloads, [copy the models folder](/guides/offline-models) from an internet-connected machine. ## Storage & Files When analyzing footage, Jumper generates Analysis files. The size of these Analysis files varies depending on a few factors like resolution and frame rate. As a rough guide, the analysis data is about 0.1% of the size of the original media file. The analysis files are saved permanently in the analysis folder. The **Clear Media** button only removes the clips from the current view in the Jumper Media Panel; it does not delete the actual analysis files. Analysis files can only be deleted by physically removing them from the analysis folder. Yes, to transfer the Analysis Files on macOS: * Open the `Terminal.app` from Spotlight, and navigate to the cache directory: ``` open ~/Library/Application\ Support/ ``` Then you can copy the `jumper-cache` folder to the same location on the other editor's machine. No, copying the Analysis Files will be additive. It will not overwrite existing files but add to them. Yes, you can change the location of your Analysis Files Folder under the `Settings` tab in Jumper. Yes. Download the models on a machine with internet access, then copy the models folder to each editorial machine. On macOS the folder is `~/.jumper/models`. On Windows it is `C:\Users\YOUR-USERNAME\.jumper\models`. See [Copy models to an offline machine](/guides/offline-models). ## Permissions Short answer: Because Final Cut Pro is a bit of a walled garden. Longer answer: Jumper uses macOS's Accessibility API to simulate button presses and menu clicks, just like Automator or BetterTouchTool. This is necessary to control FCP, since its native API doesn't expose everything we need. We're not recording video. Jumper uses Apple's screen APIs to read info like window titles and whether Final Cut Pro is playing or paused. This lets us be smart about what's happening on screen without saving or sending anything. This permission is only needed for Final Cut Pro. We need access to your Library folder to read FCP's preferences and current command set. Without this, we can't adapt to your customised setup. This is read-only and stays local. Only if you're using Final Cut Pro. If you're using Jumper with Premiere, Resolve, or Avid, skip 'em all. These permissions are FCP-specific workarounds for Apple's limitations. ## Search & Metadata Analyze the footage in Jumper to create a searchable local index from visual content, speech, recurring people, and supported technical metadata. This workflow is often called [AI video tagging or automated video logging](/core-concepts/ai-video-analysis#ai-video-tagging-and-automated-metadata-logging), but it does not write keyword tags into the source files. Use [Watch Folders](/guides/watch-folders) when newly added media should be analyzed automatically. Jumper combines local visual, speech, face, and Summary Analysis rather than relying on one general-purpose model. Editors can search the analysis directly, and compatible AI agents can navigate it through Jumper. See [AI Video Analysis and Video Understanding](/core-concepts/ai-video-analysis). Yes. Turn on [Search All Analyzed Media](/interface/search-tab#search-all-analyzed-media) to search every file Jumper has analyzed, not only media in the current editing project. This includes analyzed media on a storage drive that is currently disconnected or offline because Jumper searches its locally stored analysis data. Results outside the current project have an amber background. Reconnect an offline source drive when you need to open, import, or add the original media to a timeline. See [Manage search context](/guides/manage-search-context) for the complete workflow. Yes. Use [tag collections](/guides/tag-collections) to save search results, segments, or whole clips into personal or shared collections, then filter your search to a curated set of clips. Collections support comments, color markers, and sorting. You can use [metadata filters](/interface/search-tab#metadata-filters) to narrow visual and speech searches by supported fields such as dates, duration, location, codec, resolution, aspect ratio, frame rate, bit rate, camera, and lens information. Metadata filtering is separate from semantic search. Jumper does not currently treat a file path or folder name as a natural-language description of what appears in the footage. The "Match Source," "Match Timeline," and "Match Pasteboard frame" buttons are designed to find a frame within a maximum of a one-second difference from the input frame, as Jumper samples at 1 frame per second (FPS) during analysis. ## Workflow & Integration [Agentic video editing](/core-concepts/agentic-editing) lets a compatible AI agent operate Jumper through a local MCP server. The agent can plan searches, inspect analysis and supported NLE timelines, retrieve source ranges, and prepare clips or sequences while Jumper performs the media processing locally. No, Jumper currently focuses on media files and does not replicate the directory structure or file names. The ability to view the folder hierarchy is on the roadmap. **Multicam:** Jumper supports Multicam sequences in Premiere. If the source footage is analyzed, clicking a search result will open the Multicam sequence, not just the source file. **Proxies:** The application is not yet designed to automatically match a search result from a proxy file back to the full-resolution source file. However, analyzing proxy files is faster than full-resolution files. Yes. Jumper includes Watch Folders for automatically analyzing new media added to selected directories. See [Watch Folders](/guides/watch-folders) for setup and current behavior. Jumper relies on default DaVinci Resolve shortcuts. **Shift + I** ("Go to in point") moves the playhead when marking in/out. **Ctrl + 3** (Windows) / **Cmd + 3** (macOS) exports the current frame for the Match Source button. DaVinci Resolve must be in English for menu automation to work. Custom keyboard shortcuts will break these features. See the [DaVinci Resolve installation guide](/NLE/resolve/resolve-guide#required-shortcuts) for details. Jumper uses Avid's default **I** (Mark IN), **O** (Mark OUT), and **Q** (Go to IN point) shortcuts for Source Viewer navigation and Mark IN/OUT. Custom shortcuts for these keys will break related Jumper features. See [Required shortcuts](/NLE/avid/avid-guide#required-shortcuts) in the Avid installation guide. ## Performance & Scaling Performance on a Network Attached Storage (NAS) is heavily dependent on your network speed (e.g., 10GbE connections have been tested to work well). # Add a custom skill Source: https://docs.getjumper.io/guides/add-custom-skill Define a repeatable agent workflow for your team's export defaults This guide shows how to add a custom skill so the agent reliably follows your team's workflow — for example, always exporting clips to /exports. For background on what skills are and why they matter, see [Skills in Agentic Editing](/core-concepts/agentic-editing#skills-in-agentic-editing). ## Example Skill: Always export to /exports Suppose you want every clip export to go to /exports by default. A custom skill can encode this so the agent does it automatically. ## Create the skill In your agent's skills directory (e.g. \~/.cursor/skills/ for Cursor, or \$CODEX\_HOME/skills/ for Codex), create a new folder — for example jumper-export-exports. Inside that folder, create SKILL.md with a short description and the rule. See the example below. Run the agent with a simple search-and-export task and confirm clips land in /exports. ## Example SKILL.md ```markdown theme={null} --- name: jumper-export-exports description: When exporting clips from Jumper, always use output_dir="/exports" unless the user specifies a different path. --- Always export clips to /exports. Use export_clips with output_dir="/exports". If the user asks for a different folder, use that instead. ``` ## Related Concepts: skills, orchestration, and what agents can do Step-by-step tutorial for searching and exporting via an agent # Using Jumper with Bionic Source: https://docs.getjumper.io/guides/bionic Set up a free, private AI agent on your own machine that can search your footage and build timelines in Jumper. [Bionic](https://lmstudio.ai/bionic) runs an AI agent on your own computer, so you can ask for what you need in plain language: *"find three good shots of the harbour at sunset"*. The agent searches your footage, looks at what comes back, and tells you which shots are worth using. Nothing is sent to a cloud AI service, and there is no subscription to pay for. Bionic is our recommended agent app. It is built for the kind of multi-step work editing involves, and it can look at your footage without any extra setup. Expect to spend about ten minutes on this. ## Before you begin * Jumper is installed and running * You have [media analyzed](/core-concepts/processing) in Jumper * Your computer can run a local AI model Bigger models need more memory. Check what your machine can handle at [canirun.ai](https://canirun.ai), or read the memory estimate Bionic shows next to each model. If a model turns out to be too slow, download a smaller one. Nothing breaks. ## Setting it up Download it from [lmstudio.ai/bionic](https://lmstudio.ai/bionic) and install it like any other app. Open the model picker and download a **Local** model, meaning one that runs on your own machine rather than in the cloud. Two labels matter when you are choosing: * **Tool Use.** Required. Without it, the model cannot operate Jumper at all. * **Vision.** Recommended. This is what lets the agent look at your footage. **Gemma 4** and **Qwen 3.5** are good families to start with. Pick the largest size your machine handles comfortably, and remember you can swap it later. Bionic also runs **Cloud** models, which are larger and faster but billed to your account. It can use **Remote** models as well, running on another computer on your network over LM Link. Both work with Jumper. Only **Local** keeps everything on this machine. Go to **Settings → Connected Apps**, find **Manual MCP server setup**, and click **+ Add custom MCP**. Fill in the configuration: * **Name**: `Jumper` * **Connection**: **Web address**. Jumper runs as a local server rather than a command, so **On this computer** is the wrong option here. * **Server address**: `http://127.0.0.1:6699/mcp` * **Authentication**: **Automatic** Click **Add MCP**, then quit and reopen Bionic. Connections do not always take effect until you restart. Bionic's Connected Apps settings showing the Jumper MCP server connected, with its name, web address connection, and server address Once it is working, **Status** reads **Connected** and tells you how many Jumper tools are ready. Bionic reads the same `mcp.json` that LM Studio uses, which lives at `~/.lmstudio/mcp.json` on macOS: ```json theme={null} { "mcpServers": { "jumper": { "url": "http://127.0.0.1:6699/mcp" } } } ``` Because the two apps share this file, setting Jumper up in one of them configures it in the other. Already followed the [LM Studio guide](/guides/lm-studio)? Then Jumper is configured already, since Bionic reads the same settings. Check that Jumper appears under **Connected Apps** and move on. An agent that cannot see its own results is guessing from filenames, metadata, and search scores. One that can see will judge the shot, which is the difference between finding footage and finding the right footage. If the model you downloaded has **Vision**, you are already covered. Skip ahead. If it does not, Bionic can borrow a second model just for looking at pictures. Turn on the **Vision Subagent** in settings and choose a vision-capable model for it. You will see *"Asking vision subagent…"* whenever the agent stops to look at something. A small, fast model as the vision subagent is often quicker than pushing every frame through a large main model. That is worth trying even when your main model already has Vision. Start a session and ask something simple: ``` Can you use Jumper? ``` A working setup answers by describing what it can do with your footage. A broken one tells you it has no access. Then try a real request: ``` Find three shots of someone walking outdoors and tell me which is best. ``` That exercises search, thumbnails, and the agent's ability to look at frames in a single go. If it works, you are set up. ## What you can ask for The agent searches by what a shot looks like, by what is said in it, and by who appears in it. It can export clips for you, and it can read a timeline out of Premiere Pro, DaVinci Resolve, or Avid Media Composer and send an edited version back. See [Agentic video editing](/core-concepts/agentic-editing) for the full picture, and [Timeline import and export](/core-concepts/agentic-editing#timeline-import-and-export) for round-trips with your NLE. ## If something is not working Jumper itself has to be running, because the connection only exists while the app is open. Open Jumper, then restart Bionic. If you added Jumper by editing `mcp.json` by hand, check that the file is still valid JSON. A stray comma is enough to stop it loading. Two things to check. First, that your model has **Tool Use**, because without it the model cannot call Jumper however it is configured. Second, that Jumper is switched on under **Settings → Connected Apps**. It cannot see what it found. Either switch to a model with **Vision**, or turn on the **Vision Subagent** as described above. Searching a large library can take longer than Bionic is willing to wait. The default is 60 seconds, which is not always enough, so raise **Request timeout (seconds)** in settings. The model is too big for your machine. Download a smaller size, or lower the context length in the model's load settings. Jumper asks the local server to describe frames, and it uses the first model the server reports. If you have an embedding model loaded alongside your vision model, unload it so the vision model is the one answering. ## For the curious Jumper runs a local MCP server at `http://127.0.0.1:6699/mcp`, which is the same mechanism Claude and Codex use to talk to it. Adding Jumper under **Connected Apps** points Bionic at that address. Both ends sit on `127.0.0.1`, so nothing leaves your machine. Jumper's `get_thumbnail` tool writes a JPEG to disk and returns the path to it. The `describe_thumbnail` tool then sends that image to a local OpenAI-compatible server on port `1234`, and the short description that comes back is what the agent actually reads. Bionic starts that server itself, with just-in-time model loading, so there is nothing to switch on. You will find it under **Settings → Local Model API**, or you can confirm it from a terminal: ```bash theme={null} curl http://localhost:1234/v1/models ``` LM Studio requires you to start the same server by hand from the menu bar every time. Bionic does not. One consequence is worth knowing: `describe_thumbnail` uses the first model the server reports, which is why a stray embedding model can break the descriptions. Bionic's **vision subagent** is a separate mechanism. It handles images inside the conversation itself, which is how a text-only main model can still reason about what a shot contains. Bionic and LM Studio are made by the same team and share a configuration directory, `~/.lmstudio` on macOS. That covers `mcp.json`, your downloaded models, and more besides. In practice you can install both, configure Jumper once, and switch between them freely. Models you have already downloaded show up in either app. | | Bionic | LM Studio | | - | - | - | | Connecting Jumper | **Connected Apps** UI, or `mcp.json` | `mcp.json` via **Integrations** | | Local server on port 1234 | Automatic | Started by hand from the menu bar | | Seeing thumbnails | Vision subagent, built in | Images pasted in by hand | | Designed for | Multi-step agent work | Chat with tools | Both work well. Bionic needs less setup and handles long, multi-step jobs more gracefully, while LM Studio's chat window is a friendlier place to experiment with a lot of different models. ## Related Other agent apps you can use with Jumper The same setup in LM Studio's chat app Overview of how AI agents use Jumper What stays local and what the model actually receives # Create a Summary Source: https://docs.getjumper.io/guides/create-summary-analysis Run a Summary Analysis on selected footage and explore the layered result Summary Analysis requires a Jumper Pro license. Create a Summary Analysis for one file or a batch, then open the layered result in **Summaries**. For what summaries are and when to use them, see [Summary Analysis](/core-concepts/summary-analysis). ## Before you begin * The file must have completed [visual analysis](/core-concepts/processing). * [Speech analysis](/core-concepts/speech-search) and [face analysis](/core-concepts/face-detection) are optional, but they can add useful dialogue and character context. * Naming recognized people in the [People tab](/interface/people-tab) can make the result more useful. * An AI summarization model must be downloaded to your computer. Choose **Small**, **Medium**, **Large**, or **Extra large**. The model runs locally with the rest of Jumper's analysis. ## Create the analysis Open **Media** and make sure the footage has completed visual analysis. For a batch, select the media and use the **Summary Analysis** document control. For one file, use its configuration gear. Enter a meaningful **Analysis name** that describes its editorial use, such as “Day 2 interviews — documentary research” or “Championship final — highlight moments.” Select **Small**, **Medium**, **Large**, or **Extra large**. Download the selected AI summarization model if it is not already available locally. Select a built-in purpose to give the analysis an editorial lens, or choose **Use only my instructions** when you want the analysis guided only by your own directions and priorities. Optionally describe the question or deliverable you have in mind. Keep it concrete, such as “Identify the strongest conflict and reversal beats for a 90-second trailer.” Under **Pay extra attention to**, select the areas that matter most to the edit, such as strong dialogue, reactions, people and relationships, themes, reveals, action, or atmosphere. If useful, add **Footage context**, choose a **Summary collection**, include the transcript, select an output language, and allow named-person evidence from face analysis. Add the analysis, then start processing the selected media. Open **Summaries**. Start with the overview, then navigate into progressively more detailed sections, source time ranges, and source previews. Summary Analysis settings with analysis name, model size, purpose, collection, Specific goal, and Pay extra attention to options ## Purpose and Specific goal Use these settings together when you configure the analysis: | Setting | What it does | Example | | - | - | - | | **Built-in purpose** | Adds a familiar editorial lens to the whole analysis. | Documentary research, trailer creation, archive discovery, interview selects, or continuity review | | **Specific goal** | Adds your instructions to the selected purpose. | “Track how the relationship changes after the second interview.” | | **Use only my instructions** | Applies your **Specific goal** and selected **Pay extra attention to** priorities without adding a built-in purpose lens. | A specialized review that does not fit the available purposes | Choose the purpose closest to the work, then use **Specific goal** to make it particular to this footage and deliverable. ## Next steps * Create another analysis of the same file with a different goal. Later runs can reuse the initial observations from the first analysis. * Group related analyses in a **Summary collection** when you want to compare material across files. * Hand the result to an [AI agent](/core-concepts/agentic-editing) for research or selects work. Treat the summary as navigation context, not final source evidence. # Custom License Server Source: https://docs.getjumper.io/guides/custom-license-server Configure Jumper to authenticate against an on-premises license server for air-gapped environments Please contact support via email or Discord to get free help configuring this feature for your facility. ## Overview For production companies with air-gapped or tightly controlled networks, Jumper Pro can run as a **local license server**. This allows one online Jumper Pro machine to host licenses for other Jumper clients on the same network. When configured, the designated Jumper Pro machine (the **license server**) connects to Jumper’s cloud for activation, and other Jumper clients on your network validate their licenses against that local server. This keeps all client license traffic on your internal network while still allowing central license management. A local license server does not download models for client machines. If those machines cannot reach the internet, [copy the models folder](/guides/offline-models) onto each one. ## Prerequisites Before configuring clients to use a custom license server, ensure that: * You have designated a machine running **Jumper Pro** that will act as the license server * The license server machine has a stable internet connection for initial license activation * The license server is reachable from all client machines (same LAN/VPN, or properly routed network) * You have the correct address (IP or hostname, and port) that client machines will use to reach the license server * Network connectivity and firewall rules between Jumper clients and the license server are properly configured ## Configuring the license server Pick a machine that will run **Jumper Pro** and remain available whenever other Jumper clients need to validate licenses. Activate Jumper Pro on this machine using your license key as normal (with internet access). If you are unsure how to best set this up for your environment, please contact support via email or Discord and we will help you configure it. On every Jumper client machine that should use the local license server, navigate to the [Settings tab](/interface/settings-tab). Locate the **License Server IP address** section in the settings. This section is located below the License key field. In the License Server input field, enter the IP address of the Jumper Pro machine acting as your license server. **Example:** `192.168.1.38` The port number is always 6699 but you don't need to enter it. Click the **Apply** button to save the license server IP address configuration. After configuring the license server IP address on a client, enter that machine’s license key in the **License key** field above and click **Apply** to activate its license against your local server. ## Verifying the configuration After applying the license server IP address and license key: * The license key input field should display a green border and check mark if authentication was successful * License validation requests will now be sent to your on-premises server instead of the default Jumper license server * All license-related network traffic will stay within your internal network ## Troubleshooting **Verify license server IP address**: Double-check that the IP address is correct. Ensure there are no typos or extra spaces. **Test network access**: Try pinging the license server IP address from the device running Jumper. Verify that the port is open and accessible. **Confirm license server is running**: Ensure your on-premises license server is running and accessible on the specified port. **Check firewall settings**: Verify that firewall rules allow communication between Jumper clients and the license server on the required port. If you're running the license server on Windows and experiencing connection issues, you may need to configure Windows Defender Firewall to allow incoming connections on port 6699. Open **Windows Defender Firewall with Advanced Security** from the Start menu or Control Panel. Click **Inbound Rules** in the left sidebar, then click **New Rule** in the right sidebar. Select **Port** -> **Next** -> Select **TCP** -> Select **Specific local ports** and enter `6699` -> **Next** Select **Allow the connection** -> **Next** -> Check all profiles (Domain, Private, Public) -> **Next** Enter a name such as **Jumper Backend** -> **Finish** After creating this rule, the license server should be able to accept incoming connections on port 6699 from Jumper clients on your network. # Using face detection Source: https://docs.getjumper.io/guides/face-detection Step-by-step guide to detecting faces, naming people, and searching for them in your footage This feature requires a Jumper Pro license This guide walks you through the process of detecting faces in your footage, organizing them into collections, and searching for specific people. For an overview of how face detection works and what Collections are, see [Face detection](/core-concepts/face-detection). ## Detecting faces in media To detect faces in a media file, you need to mark the media file for face detection in the [Media tab](/interface/media-tab) (tick the checkbox in the `Mark for face detection` column) and choose a Collection to add the faces to. face_detection_6.avif By clicking the dropdown menu, you can choose a Collection or create a new one. face_detection_7.avif ## Viewing detected faces Once the media file has been analyzed, you can see your collection of faces in the [People tab](/interface/people-tab). By default, all people are unnamed. With default settings, the People Grid shows all the people that occur in at least 5 seconds of footage. face_detection_2.avif ## Naming people To assign a name to a person, click the name field and type the name. face_detection_3.avif face_detection_8.avif After assigning a name, that person becomes searchable in the [Search tab](/interface/search-tab). ## Searching for people To search for a person, click the Face icon button to bring up a list of all named people and select the person you want to search for. Pro tip: You can also type '@' in the search bar to bring up the People dropdown. face_detection_4.avif You can now search for any keywords or context and Jumper will find scenes of that person with the search query. face_detection_5.avif ### Multi-person search Select multiple named people from the Face search control to narrow results by cast or interview participants. | Mode | Finds | | :- | :- | | **AND** | Shots where every selected person appears in the same frame | | **OR** | Shots where any of the selected people appear | Combine people filters with a visual search query. For example, select **Anna** and **Ben** with **AND**, then search for `walking outside` to find exterior shots of both people together. ## Merging groups Occasionally, Jumper might create multiple groups for the same person. This is because the face detection algorithm might have low confidence in the detection. You can merge any group with any already named person by clicking the button on a group and selecting the person you want to merge it with. ## Regrouping faces If you are not happy with the grouping of the faces, you can regroup them with different parameters to improve the accuracy of the grouping. You can regroup faces by clicking the ellipsis button () next to the collection name and selecting `Regroup` in the [People tab](/interface/people-tab). regroup-collection-dialog.png In the dialog, set the **Grouping strictness**. The scale runs from loose to strict. The stricter the setting, the more similar faces must be before Jumper groups them together. | Level | Behavior | | - | - | | **Very Loose** | Faces that look different may be grouped together. | | **Loose** | Faces that look somewhat similar are grouped together. | | **Balanced** (default) | Faces are grouped by reasonable similarity. | | **Strict** | Faces that look similar are grouped together. | | **Very Strict** | Faces must be very similar to be grouped together. | | **Ultra Strict** | Faces must be extremely similar to be grouped together. | A looser setting collects more appearances of the same person but risks mixing people who look alike. A stricter setting keeps people apart but may split one person into several groups, which you can fix by [merging groups](/guides/face-detection#merging-groups). ### Remove all assigned names You can choose whether to preserve existing names when regrouping: * **Off (default)**: Already assigned names will be preserved. Only unassigned faces will be regrouped. * **On**: All assigned names will be removed before regrouping. This gives you a fresh start with the new grouping strategy. To confirm the regrouping, click the `Regroup` button. Regrouping will typically not take very long to complete, a few seconds to a minute depending on the size of the collection. ## Troubleshooting This could be because the person got grouped with another person. Regroup the collection at a stricter level (** -> Regroup**, then **Very Strict** or **Ultra Strict**) to improve the accuracy of the grouping. Regroup the collection at a stricter level (** -> Regroup**, then **Very Strict** or **Ultra Strict**) to separate people who look alike. # Install Jumper for Final Cut Pro Source: https://docs.getjumper.io/guides/fcp-guide Install the Jumper workflow extension for Final Cut Pro, grant its required macOS permissions, open it in FCP, and configure Paste Timecode. This guide installs the Jumper workflow extension for Final Cut Pro and explains the macOS Accessibility, Screen Recording, and Full Disk Access permissions it requires. ## Why does Jumper need these permissions? Due to technical limitations in FCP's native API, Jumper needs to use macOS's built-in Accessibility API to make things work. More information about why can be found at the bottom of this page ## Instructions Open the `.dmg` file that has been downloaded from the website. install-01.avif Drag the `Jumper` application into your `Applications` folder. You can now launch `Jumper` by double clicking on it within your `Applications` folder. Tick the **Enable Jumper in Final Cut Pro** toggle box mac-fcp-install-01.avif You now need to enable all the necessary permissions. Click the first **Accessibility Permissions** toggle. You'll see this alert: install-05.avif Click **OK**. You'll see this alert: install-06.avif Click **Open System Settings**. Tick the **Jumper Accessibility Helper** toggle: install-07.avif You'll be prompted to enter your system password (or use Touch ID): install-08.avif After entering your system password, **Jumper Accessibility Helper** should now be ticked. install-09.avif Now go back to `Jumper.app` and tick the next checkbox. You'll be presented with: install-10.avif Click **OK**. You'll see this alert: install-11.avif Click **Open System Settings**. It will look like this: install-12.avif Click the toggle next to `Jumper`. You'll be prompted to enter your system password (or use Touch ID): install-13.avif After entering your system password, you'll be presented with: install-14.avif Click **Later** and go back to `Jumper.app`. Click the **Full Disk Access Permission** toggle. You'll be presented with: install-15.avif Click **OK**. You'll be presented with: install-16.avif Click **Allow**. In **System Settings** find **Jumper** and click the toggle: install-17.avif You'll be presented with: install-18.avif Click **Quit & Reopen**. This will restart `Jumper.app`. Everything should now be ticked in `Jumper.app` like the below: install-19.avif Click **Open Final Cut Pro**. You can now access Jumper from the Workflow Extension toolbar icon: install-20.avif And from **Window -> Extensions -> Jumper**: install-21.avif In order for Jumper to work as fast and reliably as possible in Final Cut Pro, you need to make sure you assign the **Paste Timecode** shortcut within the Final Cut Pro Command Editor to SOMETHING. It doesn't matter what keyboard shortcut you use - it just needs to be assigned to SOMETHING. As of **Final Cut Pro 11**, Final Cut Pro now has a default shortcut key for **Paste Timecode**. For those using earlier versions of Final Cut Pro, or who have customised their keyboard shortcuts... If you click a thumbnail in Jumper without a shortcut key assigned, Jumper will display this notification: paste-timecode-01.avif If you hover over the notification, a button will appear (this is terrible UI design, but it's from Apple, and not something we can control): paste-timecode-02.avif When you click it you'll see a new notification like this: paste-timecode-04.avif And the Command Editor will automatically select the **Paste Timecode** entry: paste-timecode-03.avif You can now assign it to whatever you want, save your Command Set, and now Jumper can use it! ## About the permissions ### Accessibility Permission Jumper requires Accessibility Permission to trigger commands and menu bar items in Final Cut Pro through macOS's built-in Accessibility Automation. This is only required for Final Cut Pro - it is not required if you're only using Adobe Premiere, DaVinci Resolve or Avid Media Composer. We use the Accessibility API to programmatically "click" on buttons and menu bar items - similar to how Automator, Keyboard Maestro, BetterTouchTool, etc. works. ### Screen Recording Permission Jumper requires the Screen Recording permission to detect things on your screen when using Final Cut Pro. This is only required for Final Cut Pro - it is not required if you're only using Adobe Premiere, DaVinci Resolve or Avid Media Composer. This is a new Security Setting that started in macOS Catalina. Jumper does not record the screen. We're not "recording" the screen as a video like a QuickTime Player or a screen recording application would do - we're simply using Apple's APIs to get access to information about the contents of the screen. We use Apple's APIs to get the name of windows that are open. We also use the APIs to help detect when Final Cut Pro is playing and paused, by "looking" at the play/pause button in the Viewer. Nothing is saved to disk. Nothing is transmitted online. We simply use Apple's APIs to access screen information. We also have the option of OPTIONALLY sending screenshots when you submit feedback. Lots of other applications like Bartender and BetterTouchTool have this same limitation. We use the same techniques as the totally open-source CommandPost, so you can always inspect their code to see what's going on. ### Full Disk Access Permission Jumper requires Full Disk Access to read Final Cut Pro's Preferences File (\~/Library/Preferences/com.apple.FinalCut.plist) and the current Final Cut Pro Command Set. This is only required for Final Cut Pro - it is not required if you're only using Adobe Premiere, DaVinci Resolve or Avid Media Composer. Due to macOS's very tight security in recent releases, we need explicit permission to read files inside the user's Library folder. We only use this permission to read Final Cut Pro preferences files. ## Is Jumper compatible with CommandPost? Yes! Although Jumper does have a specialised version of CommandPost running under the hood (we called it the Final Cut Pro Automation Engine in Jumper.app and Jumper Accessibility Helper in Activity Monitor), it's fully compatible with Jumper. # Local Agentic Editing with Jumper and LM Studio Source: https://docs.getjumper.io/guides/lm-studio Set up fully local agentic editing in Jumper using LM Studio and a free open source local model. This guide walks through a fully local agentic editing setup with Jumper using LM Studio. The LLM agent runs on your machine, there is no dependency on cloud AI services, and you do not need a paid model subscription to use it. LM Studio gives you access to many local models. For Jumper, choose a model with **Tool Use** and **Vision** support. The **Gemma 4** and **Qwen 3.5** model families are good options. This guide uses a **Gemma 4** model. For air-gapped networks or absolute privacy requirements, see [Agentic editing and data privacy](/core-concepts/agentic-editing-privacy). Once LM Studio and your model are installed, this workflow can run fully locally without an internet connection. ## Before you begin * Jumper is installed and running locally * You have media analyzed in Jumper if you want to test a real search right away * You want the model and Jumper tool calls to stay on your machine Model size matters a lot for local performance. Before downloading a large model, use a tool like [canirun.ai](https://canirun.ai) or LM Studio's own memory estimate to sanity-check what your machine can handle. ## Step-by-step Go to [lmstudio.ai](https://lmstudio.ai) and download the build for your operating system. LM Studio download page showing the macOS installer Before downloading a large model, search for `gemma 4` on [canirun.ai](https://canirun.ai) and see which sizes are realistic for your hardware. The little red eye icon marks models with **Vision** support, which is required for the Jumper workflow. canirun.ai results for Gemma 4 model sizes Open LM Studio and click the robot icon in the left sidebar (**Model Search**). LM Studio sidebar with Model Search highlighted Search for `gemma 4` and pick a model that shows the capabilities you want. For Jumper, **Tool Use** and **Vision** are the key capabilities. LM Studio model search results for Gemma 4 with tool use and vision badges Once the download finishes, open the model picker, turn on **Manually choose model load parameters**, and then click the model you want to load. LM Studio model picker with several Gemma 4 models ready to load In the load settings view, you will most likely want to increase **Context Length**. In this example it is set to the maximum value, and **Remember settings** is enabled so you do not have to repeat this every time you load the model. LM Studio load model dialog with Remember settings enabled If the model is too slow, runs out of memory, or fails to load, lower the **Context Length** or move to a smaller model. When you are happy with the settings, click **Load Model**. In LM Studio chat, open **Integrations**, click the `+` menu, and choose **Edit mcp.json**. LM Studio Integrations panel with Edit mcp.json selected Add the Jumper server to `mcp.json` and save the file: ```json theme={null} { "mcpServers": { "jumper": { "url": "http://127.0.0.1:6699/mcp" } } } ``` LM Studio mcp.json file configured with the Jumper MCP server After saving, LM Studio reloads its MCP servers. Open **Integrations** and turn on `mcp/jumper`. LM Studio Integrations panel with mcp/jumper enabled and Jumper tools listed Open or start a chat and confirm that `jumper` is attached in the composer before you send a prompt. LM Studio chat composer showing the jumper integration attached Open the menu bar icon and choose **Start Server on Port 1234**. LM Studio menu bar menu showing Start Server on Port 1234 This step is required for a good Jumper workflow. LM Studio can talk to Jumper through MCP, but because of a current LM Studio limitation it cannot reliably inspect Jumper's result thumbnails directly inside the agent chat unless those images are manually pasted into the conversation. With the local server running, Jumper can ask the loaded model to describe candidate frames in the background and pass those descriptions back to the chat. In practice, that means the agent can actually validate whether the returned shots are good matches instead of guessing from filenames, metadata, or search scores alone. Ask a simple question like `Can you use Jumper?` or give it a real search request. A healthy setup should answer using the available Jumper tools instead of acting like it has no integration. LM Studio chat responding to 'Can you use Jumper?' with Jumper capabilities ## Timeline workflows With `mcp/jumper` enabled, LM Studio agents can also read timelines from Premiere Pro, DaVinci Resolve, and Avid Media Composer and send edited timelines back. See [Timeline import and export](/core-concepts/agentic-editing#timeline-import-and-export) for examples. ## Troubleshooting * **`mcp/jumper` does not appear in Integrations**: Check that your `mcp.json` is valid JSON and that Jumper is running locally on `http://127.0.0.1:6699`. * **The model behaves like it has no tools**: Make sure `mcp/jumper` is enabled in **Integrations** and that `jumper` is attached in the current chat composer. * **The agent can search but does a poor job judging which shots are the best matches**: Make sure LM Studio's local server is running on `http://127.0.0.1:1234`. * **The model is too slow or does not load**: Choose a smaller Gemma 4 variant or lower the context length in LM Studio's load settings. ## Related The same setup in Bionic, our recommended agent app Other agent apps you can use with Jumper Overview of how AI agents use Jumper through MCP What stays local and what the model actually receives # Using Jumper with local LLM agents Source: https://docs.getjumper.io/guides/local-agents Run an AI agent entirely on your own machine and let it search, review, and edit your footage through Jumper. An AI agent can do the legwork in Jumper. It finds the shots, checks whether they are any good, and builds a timeline from what it picked. Run that agent on your own computer and nothing goes to a cloud AI service, with no subscription to pay for. Your footage, your transcripts, and the agent's tool calls all stay on your machine. ## What you need With [media analyzed](/core-concepts/processing), so there is something to search. This is the program you actually chat with. Pick one below. Downloaded inside the agent app. It needs **Tool Use** to operate Jumper, and ideally **Vision** so it can look at your footage. ## Choose your agent app **Recommended.** Built for agent work, and it sees your footage out of the box. The least setup. A chat app with a large model library. More setup, and it needs a hand to look at shots. Bionic and LM Studio are made by the same team, and they share settings and downloaded models. You can install both and switch between them without redoing anything. ## What the agent can do * Search your footage by what it looks like, by what is said, and by who is on screen * Look at the frames it found and judge whether they actually match * Export clips, or read a timeline out of your NLE and send an edited one back For the full picture, see [Agentic video editing](/core-concepts/agentic-editing). To try it on real footage, follow the [agentic editing tutorial](/tutorials/agentic-editing). ## Local or cloud? Local models are free and private, but a local model is only ever as good as your hardware allows. Cloud agents like Claude and Codex are stronger and faster, at the cost of a subscription and sending your prompts off the machine. Jumper works the same way with both, since it is the same set of tools either way. To use a cloud agent instead, see [the agent settings](/interface/settings-tab#ai-agent). What stays local and what the model actually receives # Search all analyzed media across projects and drives Source: https://docs.getjumper.io/guides/manage-search-context Choose which files Jumper searches, or search every analyzed file across projects and connected or disconnected storage drives from one place. ## Overview Jumper can search your entire analyzed media library across projects and storage drives. **Search All Analyzed Media includes previously analyzed files on disconnected or offline drives**, because Jumper searches the local analysis data rather than requiring every source file to be online. Jumper's search context determines which media files and bins are included in your searches. By managing your search context, you can: * **Improve search accuracy** by focusing on relevant footage * **Speed up searches** by limiting the scope * **Search across projects** using all your analyzed media * **Organize searches** by specific bins or files You control search context through two main features: the [Context Picker](/interface/search-tab#context-picker) in the Search tab, and the "Include in search" column in the [Media tab](/interface/media-tab). ## Understanding search context By default, Jumper searches only in media files that are: 1. Included in your current project 2. Marked with a checkmark in the "Include in search" column in the Media tab The Context Picker shows you exactly which files and bins are currently included in your search context, and lets you quickly adjust them. ## Using the Context Picker The Context Picker is located in the Search tab, above the search box. It displays the files and bins that are currently included in your search. Navigate to the [Search tab](/interface/search-tab) and locate the Context Picker above the search box. The Context Picker shows all files and bins currently included in your search. This matches what's checked in the "Include in search" column in the Media tab. To change which files are included, go to the [Media tab](/interface/media-tab) and use the checkboxes in the "Include in search" column. Changes are immediately reflected in the Context Picker. The Context Picker is read-only—it displays your current search context. To change which files are included, use the "Include in search" column in the Media tab. ## Narrowing your search context When searching through large amounts of media, narrowing your search context can improve both accuracy and speed. This is especially useful when you know which specific files or bins contain the footage you're looking for. Before searching, identify which bins or specific files contain the footage you need. For example, if you're looking for B-roll shots, you might focus on a specific B-roll bin. Navigate to the [Media tab](/interface/media-tab) to manage which files are included in searches. Use the "Filter by bin" dropdown at the top of the Media tab to focus on specific bins in your project. Uncheck files or bins you don't want to search in. Only files with checkmarks in the "Include in search" column will be searched. Return to the Search tab and check the Context Picker to confirm only your target files are included. Your search will now only look through the selected files, resulting in faster and more accurate results. Narrowing your search context is recommended when you know which files or bins contain what you're looking for. This helps the models focus on relevant footage and reduces false positives. ## Using Search All Analyzed Media The **Search All Analyzed Media** option searches every file represented in your analysis folder, whether or not the file is in the current project or its storage drive is connected. This is useful when you want to find footage from previous projects, media that has not been imported yet, or archived media on an offline drive. In the Search tab, locate the Context Picker above the search box. Find the "Search All Analyzed Media" toggle in the Context Picker and switch it on. Your search will now include all analyzed media on your system, regardless of whether it's in your current project. Results from media outside your current project are displayed with an amber (orange) background. A result can still be found when its source drive is disconnected. ### When to use Search All Analyzed Media Use this feature when: * **Finding footage from previous projects** without reopening them * **Searching before importing** media into your current project * **Working with shared analysis folders** where media might be analyzed on different machines * **Looking for specific shots** across your entire media library ### Identifying external results Results from media outside your current project are clearly marked with an amber background. This helps you: * Distinguish between project media and external media * Decide whether to import external files into your project * Understand which results require additional steps to use To use external media in your project, import it through your editing software. If the source is on a disconnected drive, reconnect that drive before you open, import, or add the original file. ## Managing context for different workflows ### Workflow: Finding specific shots in a large project When working with a large project containing many hours of footage: 1. Use the Media tab's "Filter by bin" to focus on relevant bins 2. Uncheck bins that don't contain relevant footage 3. Verify your context in the Context Picker 4. Perform your search with the narrowed context This approach reduces search time and improves result relevance. ### Workflow: Searching across multiple projects When you need footage from previous projects: 1. Enable "Search All Analyzed Media" in the Context Picker 2. Perform your search 3. Look for results with amber backgrounds (external media) 4. Use the "Show in filesystem" option (if available) to locate files 5. Import the files you need into your current project ### Workflow: Organizing searches by scene or location When you have footage organized by bins (e.g., "Scene 1", "Scene 2", "Location A"): 1. Filter by the relevant bin in the Media tab 2. Ensure only files from that bin are checked in "Include in search" 3. Perform your search within that specific context 4. Switch to a different bin and repeat as needed This keeps your searches focused and organized. ## Tips for managing search context * **Start broad, then narrow**: If you're not sure where footage is, start with a broader context and narrow it down based on initial results * **Use bin filters**: The Media tab's bin filter helps you quickly focus on specific parts of your project * **Check the Context Picker regularly**: It's a quick way to verify what you're searching in before performing a search * **Remember external media**: When using "Search All Analyzed Media", remember that amber results need to be imported to use them * **Reset when needed**: If searches aren't finding expected results, check that your context includes the right files The search context settings persist between searches, so you don't need to reconfigure them for each search. However, remember to adjust them when switching between different types of searches or projects. # Copy models to an offline machine Source: https://docs.getjumper.io/guides/offline-models Download Jumper models on an internet-connected machine and copy them to air-gapped editorial stations If a firewall blocks model downloads, download the models on a machine with internet access and copy the models folder to each editorial machine. Whitelisting the [license server](/guides/custom-license-server) does not allow model downloads. License checks and model downloads are separate. ## Download the models Use a source machine with the same operating system as the editorial stations. Model availability depends on the platform. See the [model reference](/reference/machine-learning-models). On the internet-connected machine, open the [Settings tab](/interface/settings-tab#visual-model-selection). Select each model and download it. Jumper stores downloaded models in the folder below. ## Where models are stored `~/.jumper/models` The `.jumper` folder is hidden. In Finder, choose **Go > Go to Folder**, then enter: ``` ~/.jumper/models ``` `C:\Users\YOUR-USERNAME\.jumper\models` Replace `YOUR-USERNAME` with the Windows account that runs Jumper. Paste the path into File Explorer's address bar. ## Copy them onto the editorial machines Copy the `models` folder from the internet-connected machine onto removable media or your content network. Put the folder at the same path for the account that runs Jumper. On macOS that is `~/.jumper/models`. On Windows it is `C:\Users\YOUR-USERNAME\.jumper\models`. Create the `.jumper` folder if it is not there yet. Open Jumper on the editorial machine. In Settings, select the model and click **Load**. Analysis files belong to the model that created them. After loading a different model, re-analyze media before searching with it. See [Analyzing media](/core-concepts/processing#analysis-files-and-machine-learning-models). # Overcutting with Jumper Source: https://docs.getjumper.io/guides/overcutting Use Jumper to replace specific shots in your timeline with high-resolution source media ## Overview Jumper's visual search capabilities make overcutting significantly faster by allowing you to search for matching frames directly from your timeline. Instead of manually scrubbing through hours of source footage or relying on timecode alone, you can use the frame currently visible in your timeline to instantly find the corresponding scene in your high-resolution media. ## Step-by-step overcutting workflow Before overcutting, ensure all your high-resolution source footage has been analyzed. Use the [Context Picker](/interface/search-tab#context-picker) to limit your search to the bins or files containing your high-resolution source media. This ensures Jumper only searches in the relevant footage. Move your playhead to the frame of the clip you want to replace. This is typically a frame from your proxy/low-res timeline that needs to be swapped with the high-resolution source. Click the **Match Timeline Monitor** button (or **Match Timeline Viewer** in Final Cut Pro) in Jumper's Search tab. Jumper will use the current frame from your timeline to search for matching scenes in your analyzed source media. Jumper will display matching results ranked by relevance. The top result is typically the exact match you're looking for. Review the thumbnail and timestamp to confirm it's the correct scene. Since Jumper samples your media in 1FPS, you might not always get the exact frame match. However, depending on the framerate you're usually just a few frames off the exact match. Once you've found the matching scene, you can: * View it in the Source Monitor * Mark the In/Out points * Replace the proxy clip with the high-resolution source * Open the exact frame in the source file * Show the file in the project # Edit a transcript in the Script tab Source: https://docs.getjumper.io/guides/script-editor Remove unwanted lines from a transcript, review the resulting paper edit, and send or copy what remains The file must be analyzed for speech. See [Speech search](/core-concepts/speech-search) and the [Media tab](/interface/media-tab). Use this workflow to turn a full transcript into a paper edit by removing material you do not need, then send or copy the remaining lines. The dedicated Script tab with the transcript selector, search and display controls, and transcript workspace ## 1. Open a transcript Select **Script** in Jumper's top navigation, then choose an analyzed transcript from the left sidebar. On smaller windows, select the current file name above the transcript instead. You can also open the right transcript directly from your current task: * In the **Media** tab, right-click a speech-analyzed file and choose **View transcript**. * On a speech search result, click **Show in script** to open its transcript at the matching line. Speech search results with Show in script on a result card ## 2. Find the material you want to edit Type a word or phrase in **Search in this transcript**. Use **Enter** or the down arrow to move forward through matches; use **Shift** + **Enter** or the up arrow to move backward. Removed lines are excluded from these results, so the count always reflects the current paper edit. Searching for Saturn inside the Script tab, with highlighted matches and overview marks Double-click a transcript line when you need to check the source. Jumper seeks the connected NLE's Source Monitor to that timecode. ## 3. Remove unwanted lines 1. Click a line to select it. **Shift**-click another line to extend the selection. 2. Remove the selection with **Remove selected**, the **x** beside a line, or **Backspace**/**Delete**. 3. Continue until the visible transcript contains the material you want to keep. Jumper saves removals automatically as a personal local edit. They do not modify the original transcription, shared speech analysis, or media file. See [Local edits and persistence](/interface/script-tab#local-edits-and-persistence) for the complete behavior. To remove every detected silence at once, open **Ellipsis ()** and choose **Remove silence**. ## 4. Review or restore removed material One or more adjacent removed lines collapse into a red triangle row: * Click anywhere across the row to expand or collapse the removed group. * In an expanded group, click the restore arrow beside a line to return only that line to the script. * To restore everything, open **Ellipsis ()**, choose **Reset local edits…**, and confirm. Expanded removed lines in the Script tab, with individual restore buttons ## 5. Use the finished paper edit Choose the output that matches your workflow: * **NLE integration:** choose **Add all to timeline** to send every remaining line, or select specific lines and choose **Add selected to timeline**. * **Jumper Standalone:** choose **Copy script** to copy every remaining line, or select lines and choose **Copy selected**. * **File export:** open **Ellipsis ()**, then choose the required format under **Export**. The resulting timeline, copied text, or exported file contains the current edited script rather than the removed lines. Your paper edit remains saved when you switch transcripts, leave the Script tab, or restart Jumper. # Search best practices Source: https://docs.getjumper.io/guides/search-best-practices Tips and tricks for getting the best search results in Jumper ## Use descriptive searches with Ultra Accurate The **Ultra Accurate** model works best when you describe the visible shot, not just its main subject. If a broad query returns weak or noisy results, add an action, framing, setting, or another visible detail. "man" "man sitting down"
"close-up shot of a man"
Keep the wording direct. Useful visual details improve the query, while request filler such as "show me all the frames with" does not. ## Use key terms, not conversational phrases Jumper works best when you use direct, descriptive keywords rather than conversational language. "show me all the frames with a man holding a skateboard on a ramp" "man holding a skateboard on a ramp" The model focuses on the visual content described in your query, so extra words like "show me all the frames with" don't help and can sometimes reduce accuracy. ## Keep searches focused When searching for multiple unrelated items, perform separate searches rather than combining them with "or". "a polar bear or a red car" Search 1: "polar bear"
Search 2: "red car"
Separate searches give you better results because the model can focus on one concept at a time. You can always add both sets of results to your timeline if needed. ## Simplify searches one detail at a time If a descriptive search still misses the moment, simplify one detail at a time by removing an action or another restriction. "a couple kissing on bench" "a couple sitting on bench" Sometimes removing specific actions (like "kissing") and using more general terms (like "sitting") can help the model find what you're looking for. You can always refine your search after getting initial results. ## Add shot and scene details You can include cinematographic details and scene characteristics in your search queries to find specific types of shots or settings. The model will often recognize these cues and return more relevant results. **Examples:**
* "red car **close-up**" * "red car **wide shot**" * "person **medium shot**" * "building **drone shot**"
* "city street **at night**" * "beach **sunrise**" * "forest **daytime**" * "interior **daylight**" * "mountain landscape **dusk**"
## Search for text in footage Jumper's models have OCR-like capabilities, meaning they can read text that appears in your footage. You can search for signs, labels, text overlays, or any written content visible in your video. For example, searching for "STOP" might find traffic signs, or searching for a product name might find shots where that text appears on screen. It might help to add "text" or "sign" to your search to help the model find what you're looking for. "Acmecorp text" "Acmecorp sign" There's no guarantee that the model will find all occurrences of text in your footage. ## Exclude what you don't want Don't put negation in your search query. Words like "not" are unreliable in the main search box. Use [Exclude search terms](/interface/search-tab#exclude-search-terms) in the Visual search tab instead. Keep your query focused on what you want. Add unwanted concepts in the exclude dropdown. "people talking not in a meeting room" Query: "people talking"
Exclude: "meeting room"
If results still include too many false positives, increase the exclude bias with the slider or [narrow the search context](/interface/search-tab#context-picker). ## Narrow the search context The models can struggle if you are searching in large amounts of media. If you experience degraded accuracy, you might want to use the [context picker](/interface/search-tab#context-picker) to narrow down the search context. If you know what files or bins you want to search in, it's recommended to search in that specific context instead of everything. ## Temporarily hide results You can shift-click a thumbnail in the search results to temporarily remove it from view. This is especially handy when you want to add all results to the timeline except for one or a few false positives. # Shared Analysis Source: https://docs.getjumper.io/guides/shared-analysis Set up shared analysis folders on networked drives to use Jumper across multiple devices and share analysis data between users Shared analysis requires **Jumper Pro or Enterprise** on each workstation that reads analysis data created on another machine. Enterprise also lets you [restrict which analysis folders each license can use](/enterprise/access-policies#limit-access-by-production). shared-analysis-header.png ## Overview Shared analysis allows multiple Jumper users and devices to work with the same analysis data by storing it on a networked drive. When you configure Jumper to use a shared analysis folder on a network location (like a NAS, shared server, or cloud storage), all analysis data from every user and device gets stored centrally. This means: * **No duplicate analysis**: Media analyzed on one device shows up as analyzed (with a green checkmark ) when imported on another device * **Shared workload**: Multiple users can analyze different media files to the same location, distributing the analysis work across your team * **Centralized storage**: All analysis files are stored in one location, making backup and management easier * **Dedicated analysis workflow**: Set up a dedicated computer to analyze incoming footage automatically. Editors and assistant editors can pull media into their editing software and it's already analyzed and searchable. ## Setting up a shared analysis folder Select a location on a networked drive where you want to store all analysis files. This can be: * A Network Attached Storage (NAS) device * A shared server or network drive * Cloud storage services like Dropbox or Google Drive (when synced locally) * Any other network-accessible location Give the users working on this production read and write permissions to its shared analysis directory. Their devices need to be able to: * Read existing analysis files * Write new analysis files * Access the directory reliably On each device where Jumper is installed: 1. Open the [Settings tab](/interface/settings-tab) in Jumper 2. Find the **Analysis folder** section 3. Click the Folder button to browse 4. Navigate to and select the shared network location 5. Make sure all devices point to the same directory (the exact path may differ on different operating systems, but it should resolve to the same network location) Test that each device can: * Access the shared folder * See analysis files created by other devices * Create new analysis files that other devices can read ## Confidential footage and project-specific analysis folders For confidential or pre-release material that should only be accessible to specific team members, use project-specific analysis folders instead of a single folder shared across productions. Analysis data can include thumbnails and transcripts that reveal the footage, so protect it along with the source media. ### How it works Store each production's analysis in a subfolder of its project directory, and configure storage permissions so only the authorized team can access both the media and the analysis. Check permission inheritance on your storage; placing files beside restricted media does not by itself guarantee matching access. **Example workflow:** * All material for a show is stored in a project folder on network storage (e.g., `/Network/Projects/ShowName/`) * User permissions are configured so only authorized editors can access this folder * Set the analysis folder to a subfolder within the project directory (e.g., `/Network/Projects/ShowName/Analysis/`) * Users without proper credentials cannot access the analysis files, maintaining the same security boundaries as the footage itself With **Jumper Enterprise**, assign an [access policy](/enterprise/access-policies#create-a-policy) that allows only the relevant production's analysis folder. Jumper applies this restriction within the app. Storage permissions protect the files outside Jumper, including direct access to thumbnails and transcripts. ## Swarm analysis When multiple devices are configured to analyze media to the same shared location, Jumper will automatically coordinate between them to perform **swarm analysis** i.e. analyzing media files in parallel across multiple computers. This means Jumper will: * Automatically allocate media files to analyze between the available devices * Manage concurrent analysis to avoid conflicts This is especially useful when analyzing large amounts of media, as the work gets distributed across multiple machines instead of being processed sequentially on a single device. You don't have to do anything, it's enabled by default. ## Troubleshooting **Check the analysis folder path**: Make sure that the `Analysis folder` is set to the same directory on all devices. The exact path to the directory might differ on different devices (e.g., `/Volumes/SharedDrive/Analysis` on macOS vs `\\server\share\Analysis` on Windows), but it should resolve to the same network location. **Verify file visibility**: Check that analysis files created on one device are visible on other devices. If files aren't appearing, there may be a sync delay (for cloud storage) or a mounting issue (for network drives). **Check network connectivity**: Make sure the network drive is mounted and accessible from all devices. If you're using a network drive, ensure it's mounted on all devices before launching Jumper. **Verify cloud sync**: If you're using a cloud storage service, make sure the directory is synced on all devices. Cloud storage services may have delays in syncing files between devices. **Test permissions**: Try creating a test file in the shared folder from each device to verify write permissions are working correctly. **Check directory permissions**: Make sure that the users working on this production have read and write permissions on its analysis directory. **Verify network credentials**: Ensure that all devices have the necessary network credentials to access the shared location. Some network drives may require authentication. **Network speed**: Performance on a Network Attached Storage (NAS) is heavily dependent on your network speed. 10GbE connections have been tested to work well, but slower network connections may result in slower search responses. **Local caching**: Jumper may cache some data locally, but frequent access to analysis files on the network can be slower than local storage. Consider the trade-off between shared access and performance for your workflow. # Tag collections Source: https://docs.getjumper.io/guides/tag-collections Create personal or shared Tag Collections to save video segments or whole clips, add comments and color markers, filter search, and revisit selects. Tag collections let you save the clips you care about and come back to them later. Save a segment or a whole clip into a collection, organize it with comments and color markers, and filter your search to only the clips in a collection. Tag Collections are editor-created organizational tools. They are separate from [AI video tagging](/core-concepts/ai-video-analysis#ai-video-tagging-and-automated-metadata-logging), where Jumper automatically analyzes footage and builds a searchable index without writing tags into the source media. The **Tags** tab is where you browse and manage your collections. ## Tag a clip Open the **Add to tag** control on a search result or clip. For each collection you get two buttons: * **This segment** — saves the trimmed in/out range of the result. * **Whole clip** — saves the entire media file. Click again to remove the tag. A green checkmark means the segment or clip is already in that collection. To create a collection on the spot, type a name in the **New tag name** field, then choose **Personal** or **Shared**. The current segment is added to the new collection. You can also bulk-tag every result of a search at once from the search results header. ## Organize a collection In the **Tags** tab, select a collection to work with its items. Each collection supports: * **Comments** — add notes to the whole collection or to an individual item. * **Color markers** — assign one of eight colors to an item, then filter the collection by color. * **Sorting** — order items by Added oldest, Added newest, Group by clip, Clip name, File extension, or Segment duration. ## Filter search to a collection Tag filters narrow a search to the clips in one or more collections. In the visual search box, type `#` to open the tag filter (the same way `@` opens people search), or click the tag button. Select one or more collections. * Selecting multiple collections matches clips in **any** of them (**OR**). * Tag filters apply to visual search and combine with [people search](/guides/face-detection#searching-for-people). **Example:** Save your interview selects into a collection, then run a visual search for `wide shot` filtered to that collection. ## Share a collection with your team When you create a collection, choose **Shared** instead of **Personal**. Shared collections are stored in the [analysis folder](/interface/settings-tab#analysis-folder), so anyone pointing at the same folder can use and update them. Personal collections stay local to your machine. Shared collections require a shared analysis folder, which needs a Jumper Pro license. For setup, see the [Shared Analysis guide](/guides/shared-analysis). You can move a collection between Personal and Shared later. ## Related Where tag filters appear in the search controls. Set up a shared analysis folder for team collections. Understand the difference between automatic analysis and editor-created collections. # Uninstall Jumper Source: https://docs.getjumper.io/guides/uninstall A step-by-step guide to uninstalling Jumper The best way to uninstall Jumper is through the Uninstall tool. You can find the Uninstall tool in the DMG download for Jumper. SCR-20250525-jhqp.avif Some folders will be protected by macOS, so you can either give the the Uninstall Tool Full Disk Access or remove certain files manually. When you run the Uninstall tool you'll be presented with this: SCR-20250525-jiui.avif Click `Uninstall Jumper` if you want to uninstall the Jumper application, Preferences and License details. Click `Uninstall Jumper & processed files` if you also want to remove all the processed video and audio files. You will be requested to enter your macOS password: SCR-20250525-jiyr.avif A file called `Jumper Uninstall Log.txt` will be added to your Desktop, and look something like this: ``` Deleted Files and Folders: /Applications/Jumper.app /Library/Application Support/Adobe/CEP/extensions/Jumper /Users/chrishocking/.jumper/ /Users/chrishocking/Library/Logs/Jumper/ /Users/chrishocking/Library/Application Support/Jumper/ /Users/chrishocking/Library/Application Support/jumper-cache/ /Users/chrishocking/Library/Preferences/com.jumper.plist /Users/chrishocking/Library/Application Support/Adobe/CEP/extensions/Jumper /Users/chrishocking/Library/Caches/com.jumper /Users/chrishocking/Library/Caches/com.jumper.jumperAccessibilityHelper /Users/chrishocking/Library/Caches/SentryCrash/Jumper /Users/chrishocking/Library/Caches/SentryCrash/Jumper Accessibility Helper /Users/chrishocking/Library/HTTPStorages/com.jumper /Users/chrishocking/Library/WebKit/com.jumper /Users/chrishocking/Library/Application Scripts/com.jumper /Users/chrishocking/Library/Application Scripts/com.jumper.WorkflowExtension /Users/chrishocking/Library/Preferences/com.jumper.jumperAccessibilityHelper.plist Undeleted Files and Folders (Manual Deletion Required): /Users/chrishocking/Library/Containers/com.jumper.WorkflowExtension/ /Users/chrishocking/Library/Containers/com.jumper/ ``` ### Alternative method Alternatively, you can uninstall Jumper by draggin the Jumper.app from your Applications folder to the Bin/Trash. Jumper stores additional files in the following places: * `/Library/Application Support/Adobe/CEP/extensions/Jumper` * `~/.jumper/` * `~/Library/Logs/Jumper/` * `~/Library/Application Support/Jumper/` * `~/Library/Application Support/jumper-cache/` * `~/Library/Preferences/com.jumper.plist` * `~/Library/Application Support/Adobe/CEP/extensions/Jumper` * `~/Library/Caches/com.jumper` * `~/Library/Caches/com.jumper.jumperAccessibilityHelper` * `~/Library/Caches/SentryCrash/Jumper` * `~/Library/Caches/SentryCrash/Jumper Accessibility Helper` * `~/Library/HTTPStorages/com.jumper` * `~/Library/WebKit/com.jumper` * `~/Library/Application Scripts/com.jumper` * `~/Library/Application Scripts/com.jumper.WorkflowExtension` * `~/Library/Preferences/com.jumper.jumperAccessibilityHelper.plist` * `~/Containers/com.jumper.WorkflowExtension/` * `~/Containers/com.jumper/` You can also manually remove these folders or use something like AppCleaner. You can remove Jumper via Add & Remove Programs in Windows. Simply search for Add & Remove Programs in the Start bar, then search for Jumper and follow the prompts. add-remove-programs-windows.avif # Watch Folders Source: https://docs.getjumper.io/guides/watch-folders Automatically analyze new media added to selected folders for AI video tagging, visual search, speech search, face detection, and summaries. This feature requires a Jumper Pro license. watch-folders-header.png ## Overview Watch Folders allow you to specify directories that Jumper will monitor. When new, un-analyzed media files are added to these folders, Jumper will automatically start analyzing them. This is especially useful for workflows where media is regularly imported or transferred to specific locations. This automates the ingest stage of [AI video tagging and automated video logging](/core-concepts/ai-video-analysis#ai-video-tagging-and-automated-metadata-logging). Jumper creates separate analysis data and leaves the source media unchanged. ## Setting up Watch Folders Navigate to the [Settings tab](/interface/settings-tab) in Jumper. Locate the Watch Folders section in the settings. Click the `Add Watch Folder` button to add a new Watch Folder to bring up the Add Watch Folder dialog. In the dialog, you can set up: * **Folder path**: The directory to monitor * **Analysis types**: Choose which types of analysis to perform (visual analysis, speech analysis, face detection, or any combination) * **Language**: Select the language for speech analysis * **Face collection**: Choose which face collection to add detected faces to * **Analysis output folder**: Optionally specify a custom location for analysis files (otherwise uses the default analysis folder) * **Metadata filters**: Optionally use [technical metadata](/interface/search-tab#metadata-filters) to control which files are analyzed * **Exclusions**: Optionally skip media inside the Watch Folder using **Excluded folders** (folder name patterns), **Excluded filename patterns**, or **Excluded extensions** Click the `Start` button to start monitoring the Watch Folder. When new media is added to the Watch Folder, Jumper will automatically start analyzing it. Files analyzed through Watch Folders are not currently added to the Media Table, so they won't appear in search results even after analysis completes. To make analyzed files searchable, manually add the folder or files to the [Media Table](/interface/media-tab). This limitation will be addressed in a future update. You can add multiple Watch Folders to monitor different directories simultaneously with different settings. ## Managing Watch Folders ### Global start/stop button The global start/stop button at the top-right of the Watch Folders section controls all Watch Folders at once. When stopped, no Watch Folders will monitor or analyze files, regardless of their individual settings. ### Individual Watch Folder control Each Watch Folder has its own toggle switch that enables or disables monitoring for that specific folder. This allows you to: * Keep some Watch Folders active while pausing others * Temporarily disable a specific Watch Folder without removing it ### Editing Watch Folder settings watch-folder-settings.png You can edit a Watch Folder's configuration at any time by selecting it in the list. This allows you to change the analysis types, language, face collection, output folder, or exclusions without removing and re-adding the Watch Folder. ### Removing Watch Folders To stop monitoring a directory permanently, you can remove the Watch Folder from your settings. This will stop automatic analysis for that location, but any files already analyzed will remain searchable. ## Troubleshooting Files analyzed through Watch Folders are not currently added to the Media Table, so they won't appear in search results even after analysis completes. **Workaround:** To make analyzed files searchable, manually add the folder or files to the [Media Table](/interface/media-tab). This limitation will be addressed in a future update. ## Related Understand how automatic analysis creates a searchable local index. Learn how Jumper stores analysis separately from source media. # Jumper Documentation Source: https://docs.getjumper.io/index Use Jumper to search visual content, dialogue, and people locally across analyzed footage in Premiere Pro, Resolve, Avid, Final Cut Pro, or Standalone. Jumper is a local AI footage-search tool for Adobe Premiere Pro, DaVinci Resolve, Avid Media Composer, and Final Cut Pro. Search visual content, spoken dialogue, and people without uploading your footage. With **Search All Analyzed Media**, Jumper can search your entire analyzed library across projects and storage drives—including media on drives that are currently disconnected—not only clips in the open editing project. [Learn how cross-project and offline-drive search works](/interface/search-tab#search-all-analyzed-media). jumper_in_premiere_smile.avif Works inside Adobe Premiere Pro, Final Cut Pro, DaVinci Resolve, and Avid Media Composer Everything runs locally and offline on your device. No cloud uploads, no internet connection required. Jumper uses the latest models and we update them regularly.