# Loom Video Downloader (`parseforge/loom-video-downloader`) Actor

Downloads Loom videos from share or embed URLs and returns the MP4 download link, full transcript, and WebVTT captions for each video.

- **URL**: https://apify.com/parseforge/loom-video-downloader.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Videos, Automation
- **Features:** Limited permissions
- **Stats:** 68 total users, 2 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $24.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### Loom Video Downloader

**Download Loom videos in HD from any share or embed URL, with full transcript and captions.** Each video is saved as an MP4 file, and the transcript and WebVTT captions are returned as text fields. No login, no API key, no watermark removal needed.

Loom's official download option is hidden behind a paid plan and a manual click per video. This Actor reads the public share and embed pages directly, extracts the original MP4 file, and returns the download URL, transcript, and captions in one fixed schema. Feed it a list of Loom video URLs and get back a dataset ready for archiving, analysis, or repurposing.

| Who uses it | What they scrape Loom for |
|---|---|
| Content marketers | Archive competitor Loom videos and repurpose the transcripts into blog posts |
| Sales enablement teams | Back up every product demo and sales call recording for compliance |
| Researchers | Collect Loom videos at scale and analyze the spoken content via transcripts |
| Course creators | Download their own Loom lessons and migrate them to a new platform |

### What it does

This Actor downloads Loom videos from share or embed URLs and returns each video's download URL, transcript, and captions as a flat row.

- 🎬 **Bulk download:** pass up to a million Loom URLs per run and get every MP4 download link in one dataset.
- 📝 **Full transcript:** each row includes the complete spoken text, ready for search or summarization.
- ⏱️ **Timestamped captions:** WebVTT captions are returned with millisecond-accurate timing for subtitles or clips.
- 🔗 **Share and embed support:** works with both loom.com/share/ and loom.com/embed/ URL formats.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Loom data

**📚 Archive company knowledge.**

An ops manager feeds a list of internal Loom training videos and stores the MP4 files plus transcripts in a searchable archive.

**📊 Analyze competitor content.**

A market researcher downloads competitor product demos and runs the transcripts through a topic model to spot messaging gaps.

**🎓 Migrate course content.**

A course creator downloads all their Loom lessons and re-uploads the MP4 files to a new LMS without losing captions.

**🔍 Build a video search engine.**

A developer scrapes Loom videos and indexes the transcripts so users can search for spoken keywords across hundreds of recordings.

### Why choose this scraper

|  | What you get |
|---|---|
| **No Loom API needed** | The Actor reads the public video pages directly, so you never register an app or manage OAuth tokens. |
| **Original MP4 quality** | You get the direct download URL for the source video file, not a screen recording. |
| **Transcript included** | The full spoken text is extracted and returned as a plain string, ready for NLP or search. |
| **Captions with timestamps** | WebVTT captions give you word-level timing for subtitles, clips, or accessibility work. |

### How it compares

No other Store actor targets Loom the same way, so the honest comparison is with the alternatives teams actually weigh.

| | Loom Video Downloader | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When Loom changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor from a list of Loom video URLs, and choose whether to include the full transcript and WebVTT captions for each video. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "urls": [
    "https://www.loom.com/share/e41353f2fe1c43eba6c6829693e0f2c5"
  ],
  "maxItems": 10,
  "includeTranscript": true,
  "includeCaptions": true
}
```

A larger pull:

```json
{
  "urls": [
    "https://www.loom.com/share/e41353f2fe1c43eba6c6829693e0f2c5"
  ],
  "maxItems": 200,
  "includeTranscript": true,
  "includeCaptions": true
}
```

### Pricing

Pay-per-result: **$0.032 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $3.20 |
| 1,000 results | $32.00 |
| 10,000 results | $320.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Loom Video Downloader](https://apify.com/parseforge/loom-video-downloader?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Loom through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/loom-video-downloader"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that the URLs are publicly accessible and use the /share/ or /embed/ format. Private or deleted videos will return an error row.

**Why is the transcript empty?**

Some Loom videos do not have a transcript available, especially if the owner disabled captions. Try enabling includeTranscript and check the video's settings.

**Why did the download URL expire?**

Loom signs download URLs with a time limit. Re-run the Actor to get a fresh URL, or download the file immediately after the run.

**Why am I getting a 403 error?**

The video may be private or restricted to certain domains. Make sure the video is publicly shared and not password-protected.

**Can I download a video that requires a password?**

No. Password-protected Loom videos are not accessible without authentication, and this Actor does not support login.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Loom account or API key? | No. The Actor reads the public share and embed pages directly, so no login or API key is required. |
| What video quality do I get? | You get the original MP4 file that Loom serves on the public page, which is typically the highest quality available for that video. |
| Can I download private Loom videos? | No. The Actor can only access videos that are publicly shared via a /share/ or /embed/ URL. Private videos require authentication. |
| How many videos can I download in one run? | You can pass up to 1,000,000 URLs per run. The Actor processes them sequentially and returns one row per video. |
| Does the transcript include speaker labels? | No. The transcript is a single string of spoken text without speaker identification. Captions include timestamps but not speaker names. |
| What is the output format? | The Actor returns a dataset with one row per video. Each row contains the video URL, download URL, transcript, and captions. You can export to JSON, CSV, Excel, or XML. |
| Can I download only the audio? | No. The Actor downloads the full MP4 video file. You can extract audio from the MP4 using a tool like ffmpeg. |
| Does the Actor work with Loom's new URL format? | Yes. It supports both the classic loom.com/share/ and the newer loom.com/embed/ URL formats. |
| Are the download links permanent? | The download URLs are signed by Loom and may expire after some time. We recommend downloading the files soon after the run completes. |
| Can I schedule this Actor to run automatically? | Yes. You can set up a schedule in Apify to run the Actor daily, weekly, or at any custom interval. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Loom, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `urls` (type: `array`):

List of Loom video URLs to download (e.g. https://www.loom.com/share/abc123). Supports /share/ and /embed/ URLs.

## `maxItems` (type: `integer`):

Maximum number of videos to download per run.

## `includeTranscript` (type: `boolean`):

Fetch the full video transcript text. Adds a 'transcript' field with the spoken content.

## `includeCaptions` (type: `boolean`):

Fetch captions in WebVTT format with timestamps. Adds a 'captions' field.

## Actor input object example

```json
{
  "urls": [
    "https://www.loom.com/share/e41353f2fe1c43eba6c6829693e0f2c5"
  ],
  "maxItems": 10,
  "includeTranscript": true,
  "includeCaptions": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://www.loom.com/share/e41353f2fe1c43eba6c6829693e0f2c5"
    ],
    "maxItems": 10,
    "includeTranscript": true,
    "includeCaptions": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/loom-video-downloader").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": ["https://www.loom.com/share/e41353f2fe1c43eba6c6829693e0f2c5"],
    "maxItems": 10,
    "includeTranscript": True,
    "includeCaptions": True,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/loom-video-downloader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://www.loom.com/share/e41353f2fe1c43eba6c6829693e0f2c5"
  ],
  "maxItems": 10,
  "includeTranscript": true,
  "includeCaptions": true
}' |
apify call parseforge/loom-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/loom-video-downloader"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/85GHwccOv5p6wBS1c/builds/lSS468P8sGZSvq3DZ/openapi.json