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

Process one publicly accessible Loom share page for structured metadata and an optional stored video file. Choose metadata-only mode or a download quality preference.

- **URL**: https://apify.com/truefetch/loom-video-downloader.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Videos, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Loom Video Downloader converts one accessible Loom share page into a structured Dataset item and can optionally store the video file alongside its metadata in Apify.

- The effective input surface has two fields and requires only a Loom share URL.
- Four quality values distinguish metadata-only inspection from three media-download preferences.
- The output contract lists 39 fields for the recording, owner, media properties, processing context, and file delivery.
- Comment retrieval is not a public feature; the reserved `comments` array is normally empty.

**[Run a one-result test](https://apify.com/truefetch/loom-video-downloader)**

**[View API](https://apify.com/truefetch/loom-video-downloader/api)**

Publish the Actor, use an “anyone with the link” recording, and validate metadata before requesting a file.

### What does Loom Video Downloader do?

Loom Video Downloader handles a single Loom share page. It reads the public recording information available at that URL and normalizes it into an Apify Dataset record. Depending on the page, useful values can include the recording ID, title or description, thumbnail, duration, publication time, owner details, dimensions, frame rate, and audio labels.

When the input requests a download, the Actor can store an available video file and return its URL. Metadata mode skips that transfer and is the appropriate first test for a new page type or permission configuration.

Loom access settings matter more than the mere existence of a link. Loom’s own sharing guidance distinguishes anyone-with-link access from workspace-only, named-person, login-required, and password-protected sharing. This Actor exposes no Loom login, workspace credential, or password input, so those restricted recordings are outside the public contract.

### How do I run Loom Video Downloader?

Open the Actor draft in Apify Console and verify that it is branded for Loom. Choose a recording configured for public link access. Folder links, workspace library pages, editor URLs, and account pages do not match the one-recording input.

This README uses a share-link-shaped scenario:

```json
{
  "video_url": "https://www.loom.com/share/8961c11d90fd42d6a8d1bacc71834c90",
  "video_quality": "metadata"
}
```

The identifier is illustrative; replace it with a Loom share page you are authorized to test. Start with metadata and inspect **Results**. If the output contains the expected identity and media fields, repeat with a download quality only when the file is needed.

Do not add cookies, passwords, or workspace secrets as undocumented fields. The schema will not turn restricted content into a public recording.

### What data does Loom Video Downloader return?

The Actor uses a 39-field cross-video contract:

| Area | Dataset fields |
|---|---|
| Processing | `processor`, `processed_at` |
| Recording | `id`, `thumbnail`, `platform`, `title`, `description`, `duration`, `published_at` |
| Owner | `author`, `author_id`, `author_url` |
| Classification | `categories`, `tags` |
| Available engagement | `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Media properties | `width`, `height`, `fps`, `audio_title`, `audio_artist` |
| Reserved and file | `comments`, `video` |

An abbreviated illustrative item for the same scenario is:

```json
{
  "id": "0123456789abcdef0123456789abcdef",
  "platform": "Loom",
  "title": "Example product walkthrough",
  "author": "Example owner",
  "thumbnail": "https://example.com/loom-thumbnail.jpg",
  "duration": null,
  "comments": [],
  "video": ""
}
```

This is a shape example, not a live recording response. Loom may not expose every cross-platform field, so null and empty values are valid. The public schema does not request viewer comments. In metadata mode, `video` is intentionally empty.

Source-dependent fields also present in every item:

| Field | Meaning |
|---|---|
| `source_url` | Canonical page URL of the item on its own platform |
| `media_type` | Kind of media the source reports, such as video or audio |
| `live_status` | Whether the item is a recording, currently live, or a finished stream |
| `availability` | Source visibility, such as public, unlisted, or needs\_auth |
| `age_limit` | Minimum viewer age the source enforces; zero means no restriction |
| `language` | Primary language of the item as reported by the source |
| `followers` | Follower or subscriber count of the author at processing time |
| `is_verified` | Whether the author's account carries a verified badge |
| `saves_count` | Times viewers saved the item, on sources that expose it |
| `file_ext` | Container extension of the selected media, such as mp4 or webm |
| `file_size` | Size of the selected media in bytes, exact or approximate |
| `subtitles` | Language codes of published subtitle tracks; auto-captions excluded |
| `chapters` | Chapter markers with title and start and end time in seconds |

### What inputs can I configure?

The effective schema offers:

| Input | Required | Meaning |
|---|---:|---|
| `video_url` | Yes | One publicly accessible Loom share page. |
| `video_quality` | No | `metadata`, `low`, `medium`, or `high`; metadata skips file storage. |

The URL includes a consistent share-link example. The optional quality input has no prefill, preserving whether the caller explicitly selected a mode. No comments, password, account, workspace, folder, date, or batch input exists.

### What platforms and markets does Loom Video Downloader cover?

Coverage is defined by the submitted Loom share page rather than a market. There is no country, language, team, workspace, creator, folder, date, or search filter.

An “anyone with the link” recording is the intended test case. Workspace-member-only and specific-person sharing can require login, while a password adds a credential that this schema cannot provide. Search-engine indexing is not required if the share link itself is publicly accessible, but the caller must possess the link.

Loom may change share behavior or media delivery. Test recordings using the permission modes your application will receive, and do not claim that success with one public demo proves access to internal company recordings.

For release testing, build a small permission matrix rather than relying on a single link: one recording open to anyone with the link, one workspace-only recording, one recording shared with named people, and one password-protected recording. The expected public contract is success only for the genuinely accessible case. Record the response and run status for each row. This makes the access boundary reviewable and prevents a browser’s signed-in state from being mistaken for Actor capability.

### Why use Loom Video Downloader?

The Actor can make an authorized Loom recording usable outside a manual browser flow. A product team can attach structured title, owner, duration, and thumbnail data to a review task. An engineering team can archive a permitted walkthrough with the run timestamp. A downstream service can read a Dataset item and retrieve the stored file.

Metadata-first testing reduces transfer and makes permission failures visible before file work. The thumbnail-first overview helps people identify recordings. Nullable fields avoid inventing engagement or media values that Loom did not expose.

Public Store statistics, ratings, reviews, Actor ID, and observed reliability do not exist to support marketing claims.

### Who is Loom Video Downloader for?

Developers can integrate an authorized share-link submission form. Product, support, and engineering operations can preserve public product demos, bug reproductions, onboarding clips, or tutorials. Researchers can document publicly shared recordings in a defined sample. AI teams can pass an authorized stored video to a separate transcription or indexing step.

Console users can test a single recording without code once the draft is available.

This Actor is not for workspace export, private library access, password bypass, folder crawling, account automation, comment collection, or rights determination. It does not replace Loom’s own workspace administration or retention controls.

### How can I use Loom Video Downloader through the API or MCP?

The following API call is syntactically valid. Replace the illustrative ID:

```bash
curl -X POST "https://api.apify.com/v2/acts/truefetch~loom-video-downloader/runs?token=$APIFY_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"video_url":"https://www.loom.com/share/8961c11d90fd42d6a8d1bacc71834c90","video_quality":"metadata"}'
```

The matching hosted MCP configuration is:

```json
{
  "mcpServers": {
    "apify-loom": {
      "url": "https://mcp.apify.com?tools=truefetch/loom-video-downloader",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}
```

Protect the token and follow the [official Apify MCP instructions](https://docs.apify.com/integrations/mcp).

### How much does Loom Video Downloader cost?

The local metadata contains flat event prices, not a verified published offer:

| Declared event | Unit | Local price |
|---|---|---:|
| `apify-actor-start` | Actor start | $0.01 |
| `actor_usage` | Metered usage event | $0.00001 |
| `metadata` | One recording processed without file download | $0.13 |
| `download` | One recording processed with file storage | $0.28 |

The smallest metadata run declares $0.14 in fixed start and metadata events, before metered usage or platform costs. A download uses the $0.28 event instead of the metadata event.

Verify live publication settings and the completed run’s charges before scaling. No tier-specific discount prices are present locally.

### How does Loom Video Downloader compare with alternatives?

| Option | Good fit | Limitation |
|---|---|---|
| Loom Video Downloader | One public share page needs normalized metadata or a stored file | Publication and representative permission tests remain pending. |
| Loom’s own download controls | A permitted user manually saves a recording | Less suitable for Dataset and API automation. |
| Video To Text | The desired output is spoken text | Transcription is different from recording metadata and storage. |
| Best Video Downloader | Inputs span several supported video hosts | Broader scope with fewer Loom-specific permission explanations. |

The key decision is access: a public link can fit this Actor, while a restricted workspace recording requires an authorized Loom workflow.

### What are the limits and troubleshooting steps?

Only one share page is accepted. There are no credentials, password, folder, workspace, batch, comments, or search controls. Fields can be null. Quality is a preference. Repeating a run does not deduplicate earlier results.

If metadata fails, open the share link in a private browser window. Confirm it is the recording page and that “anyone with the link” access is enabled. Replace the illustrative README URL with the real share URL. Test file mode only after metadata succeeds.

If `video` is empty in download mode, inspect the run log and storage result. Never treat an empty engagement value as zero. The public Store and Issues surfaces were unavailable at this checkpoint, so live defect history is unknown.

Loom owners can change sharing settings or delete a recording after a successful run. A schedule should therefore expect later failures and should not use an old stored file as evidence that the source remains public. Decide separately how long your organization may retain authorized recordings and their metadata.

### Frequently asked questions

#### Can it access workspace-only recordings?

No workspace login or account credential input exists.

#### Can I provide a Loom password?

No password field is exposed. Password-protected recordings are outside the public input contract.

#### Does it process a public folder?

No. Supply one recording share page, not a folder.

#### Are Loom comments returned?

No comments input exists; the reserved array is normally empty.

#### Does high guarantee 4K?

No. Available media for that recording determines the result.

#### Why are fields null?

The share page did not expose those values. Null is not a measured zero.

#### Can I schedule it?

Yes, but a schedule repeats one configured URL. Confirm that repetition is useful.

#### Does a public share link stay public forever?

No. The owner can change access or remove the recording, so every run must handle current availability.

#### How do I confirm a share link is genuinely public?

Open the `loom.com/share/<id>` address in a private browser window. If the recording plays with no sign-in prompt and no workspace banner, the Actor can reach it. Links set to workspace-only or to named viewers return no playable manifest, and the run ends without a Dataset item.

#### Why are engagement fields empty for Loom recordings?

Loom does not publish view, like, share, or comment counters on a public share page, so `view_count`, `like_count`, `shares_count`, and `comment_count` stay null. The fields remain in the contract so one schema covers every supported source, and null means the source did not supply a value.

#### What should I capture when reporting a Loom problem?

Record the exact share URL you submitted, the selected `video_quality`, the run ID, and whether the recording plays in a private browser window. Those four facts separate an access change on the Loom side from a processing problem worth investigating. Note the terminal status and whether a Dataset item was written, because a run that ends without an item charges no result event and usually points at sharing permissions rather than the Actor. Redact any internal recording title before sharing the details outside your team.

### Related TrueFetch Actors

- [Best Video Downloader](https://apify.com/truefetch/best-video-downloader) handles mixed video-host inputs.
- [Video To Text](https://apify.com/truefetch/video-to-text) produces a speech transcript from authorized media.
- [Video Subtitles Downloader](https://apify.com/truefetch/video-subtitles-downloader) retrieves available caption tracks.

### Support

- [Apify Actor dashboard](https://apify.com/truefetch/loom-video-downloader)
- [Apify Actor API reference](https://apify.com/truefetch/loom-video-downloader/api)
- [Apify MCP documentation](https://docs.apify.com/integrations/mcp)
- [Loom sharing guidance](https://www.loom.com/community/how-to-share-your-video)
- [TrueFetch community](https://t.me/TrueFetch)
- [Direct support](https://t.me/AiAgentApi)

Include the public Actor link, stable ID, safe Loom permission setup, redacted input, and run ID in support requests.

**[Run a one-result test](https://apify.com/truefetch/loom-video-downloader)**

**[View API](https://apify.com/truefetch/loom-video-downloader/api)**

# Actor input Schema

## `video_url` (type: `string`):

Publicly accessible Loom share page URL to process.

## `video_quality` (type: `string`):

Preferred download quality, or metadata-only mode without a video file.

## Actor input object example

```json
{
  "video_url": "https://www.loom.com/share/8961c11d90fd42d6a8d1bacc71834c90"
}
```

# Actor output Schema

## `results` (type: `string`):

All video details and optional download links with full engagement stats and comments

# 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 = {
    "video_url": "https://www.loom.com/share/8961c11d90fd42d6a8d1bacc71834c90"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/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 = { "video_url": "https://www.loom.com/share/8961c11d90fd42d6a8d1bacc71834c90" }

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

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

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

```

## CLI example

```bash
echo '{
  "video_url": "https://www.loom.com/share/8961c11d90fd42d6a8d1bacc71834c90"
}' |
apify call truefetch/loom-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=truefetch/loom-video-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/cgj5mAnzj5T0nEvF9/builds/2DGcVvJjnJhOSchMO/openapi.json